From afce94a5f266e101430a83af46b918e7b984c07e Mon Sep 17 00:00:00 2001 From: Adarsh Divakaran Date: Mon, 16 Nov 2026 09:04:08 +0530 Subject: [PATCH 1/4] feat: add static typing support via optional typing extra Adds serpapi-stubs, a separate type-stub package built from stubs/ and installed with the serpapi[typing] extra. Engine parameter types are generated from the SerpApi Playground, with workflows to check, refresh and release the stubs. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .github/workflows/release.yml | 105 +- .github/workflows/stubs-refresh.yml | 95 + .github/workflows/stubs-release.yml | 108 + .github/workflows/stubs.yml | 61 + CONTRIBUTING.md | 48 +- README.md | 12 + docs/examples/google-images-search.md | 6 +- docs/examples/google-lens-image-upload.md | 2 +- docs/examples/google-play-store-apps.md | 5 +- docs/user_guide/async-search-archive.md | 7 +- pyproject.toml | 1 + stubs/.gitignore | 4 + stubs/LICENSE | 21 + stubs/MANIFEST.in | 2 + stubs/README.md | 99 + stubs/data/engines.json | 10202 ++++++++ stubs/pyproject.toml | 50 + stubs/serpapi-stubs/__init__.pyi | 20 + stubs/serpapi-stubs/__version__.pyi | 1 + stubs/serpapi-stubs/core.pyi | 24515 ++++++++++++++++++++ stubs/serpapi-stubs/engine_params.pyi | 8154 +++++++ stubs/serpapi-stubs/exceptions.pyi | 15 + stubs/serpapi-stubs/http.pyi | 28 + stubs/serpapi-stubs/models.pyi | 21 + stubs/serpapi-stubs/textui.pyi | 6 + stubs/serpapi-stubs/utils.pyi | 3 + stubs/tests/conftest.py | 4 + stubs/tests/stubtest_allowlist.txt | 2 + stubs/tests/test_fetch_engines.py | 112 + stubs/tests/test_generate_stubs.py | 149 + stubs/tests/test_packaging.py | 7 + stubs/tests/test_release_version.py | 118 + stubs/tests/typecheck/check_errors.py | 32 + stubs/tests/typecheck/check_usage.py | 77 + stubs/tools/fetch_engines.py | 194 + stubs/tools/generate_stubs.py | 380 + stubs/tools/release_version.py | 115 + tests/test_typing_extra.py | 9 + 38 files changed, 44770 insertions(+), 20 deletions(-) create mode 100644 .github/workflows/stubs-refresh.yml create mode 100644 .github/workflows/stubs-release.yml create mode 100644 .github/workflows/stubs.yml create mode 100644 stubs/.gitignore create mode 100644 stubs/LICENSE create mode 100644 stubs/MANIFEST.in create mode 100644 stubs/README.md create mode 100644 stubs/data/engines.json create mode 100644 stubs/pyproject.toml create mode 100644 stubs/serpapi-stubs/__init__.pyi create mode 100644 stubs/serpapi-stubs/__version__.pyi create mode 100644 stubs/serpapi-stubs/core.pyi create mode 100644 stubs/serpapi-stubs/engine_params.pyi create mode 100644 stubs/serpapi-stubs/exceptions.pyi create mode 100644 stubs/serpapi-stubs/http.pyi create mode 100644 stubs/serpapi-stubs/models.pyi create mode 100644 stubs/serpapi-stubs/textui.pyi create mode 100644 stubs/serpapi-stubs/utils.pyi create mode 100644 stubs/tests/conftest.py create mode 100644 stubs/tests/stubtest_allowlist.txt create mode 100644 stubs/tests/test_fetch_engines.py create mode 100644 stubs/tests/test_generate_stubs.py create mode 100644 stubs/tests/test_packaging.py create mode 100644 stubs/tests/test_release_version.py create mode 100644 stubs/tests/typecheck/check_errors.py create mode 100644 stubs/tests/typecheck/check_usage.py create mode 100644 stubs/tools/fetch_engines.py create mode 100644 stubs/tools/generate_stubs.py create mode 100644 stubs/tools/release_version.py create mode 100644 tests/test_typing_extra.py diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 7e37094..4bdb238 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -71,9 +71,98 @@ jobs: path: dist/ if-no-files-found: error + stubs-check: + name: Check stubs + uses: ./.github/workflows/stubs.yml + + stubs-series: + name: Check for an existing stub release + runs-on: ubuntu-latest + outputs: + publish: ${{ steps.check.outputs.publish }} + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - id: check + name: Require a matching tag and publish only once per SDK series + run: python stubs/tools/release_version.py --series-check "$GITHUB_REF_NAME" + + stubs-build: + name: Build stub distribution + needs: [test, stubs-check, stubs-series] + if: needs.stubs-series.outputs.publish == 'true' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: Build sdist and wheel + working-directory: stubs + run: | + pip install build + python tools/release_version.py + python -m build + + - uses: actions/upload-artifact@v7 + with: + name: stubs-dist + path: stubs/dist/ + if-no-files-found: error + + # Stubs are published first so that `serpapi[typing]` resolves as soon as the SDK is available. + publish-stubs: + name: Publish serpapi-stubs + needs: [build, stubs-series, stubs-build] + if: needs.stubs-series.outputs.publish == 'true' + runs-on: ubuntu-latest + environment: + name: pypi-stubs + url: https://pypi.org/p/serpapi-stubs + permissions: + contents: read + id-token: write + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - uses: actions/download-artifact@v8 + with: + name: stubs-dist + path: dist/ + + - id: final-check + name: Do not supersede an existing stub series + run: python stubs/tools/release_version.py --series-check "$GITHUB_REF_NAME" + + - name: Publish to PyPI + if: steps.final-check.outputs.publish == 'true' + uses: pypa/gh-action-pypi-publish@release/v1 + publish: name: Publish release - needs: [build] + needs: [test, build, stubs-check, stubs-series, stubs-build, publish-stubs] + # A status function is needed so skipped stub jobs do not skip this job; unlike `always()`, + # `!cancelled()` still lets a cancelled run stop before the SDK is published. + if: >- + !cancelled() && + needs.test.result == 'success' && + needs.build.result == 'success' && + needs.stubs-check.result == 'success' && + needs.stubs-series.result == 'success' && + (needs.stubs-build.result == 'success' || + (needs.stubs-build.result == 'skipped' && needs.stubs-series.outputs.publish == 'false')) && + (needs.publish-stubs.result == 'success' || + (needs.publish-stubs.result == 'skipped' && needs.stubs-series.outputs.publish == 'false')) runs-on: ubuntu-latest environment: name: pypi @@ -101,6 +190,9 @@ jobs: smoke-test: name: Smoke test published package needs: [publish] + # `publish` still runs when the stub jobs are skipped, but a plain `needs` would skip this job + # because its grandparents were skipped. + if: ${{ !cancelled() && needs.publish.result == 'success' }} runs-on: ubuntu-latest steps: - uses: actions/setup-python@v6 @@ -110,9 +202,10 @@ jobs: - name: Wait for PyPI availability run: | VERSION=${GITHUB_REF_NAME#v} - echo "Waiting for serpapi==$VERSION on PyPI..." + echo "Waiting for serpapi==$VERSION and its serpapi-stubs series on PyPI..." for i in $(seq 1 12); do - if pip index versions serpapi 2>/dev/null | grep -q "$VERSION"; then + if pip index versions serpapi 2>/dev/null | grep -q "$VERSION" \ + && pip index versions serpapi-stubs 2>/dev/null | grep -qF "$VERSION."; then echo "Available!" exit 0 fi @@ -126,6 +219,12 @@ jobs: VERSION=${GITHUB_REF_NAME#v} pip install "serpapi==$VERSION" + - name: Install typing extra + run: | + VERSION=${GITHUB_REF_NAME#v} + pip install "serpapi[typing]==$VERSION" + pip show serpapi-stubs + - name: Verify import and version env: API_KEY: ${{ secrets.API_KEY }} diff --git a/.github/workflows/stubs-refresh.yml b/.github/workflows/stubs-refresh.yml new file mode 100644 index 0000000..82f5896 --- /dev/null +++ b/.github/workflows/stubs-refresh.yml @@ -0,0 +1,95 @@ +name: Refresh serpapi-stubs + +# Regenerates the engine snapshot and stubs from the SerpApi playground and opens (or updates) a PR. +# The PR is closed again if a later run finds that the stubs match the default branch. +# Pull requests opened with GITHUB_TOKEN do not trigger other workflows, so set the +# STUBS_REFRESH_TOKEN secret (fine-grained PAT or GitHub App token) to run checks on the PR. +on: + schedule: + - cron: "17 4 * * 1" + workflow_dispatch: + +concurrency: + group: serpapi-stubs-refresh + cancel-in-progress: false + +permissions: + contents: write + pull-requests: write + +env: + BRANCH: bot/refresh-serpapi-stubs + +jobs: + refresh: + name: Refresh stubs + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + ref: ${{ github.event.repository.default_branch }} + token: ${{ secrets.STUBS_REFRESH_TOKEN || github.token }} + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: Fetch engine metadata + run: python stubs/tools/fetch_engines.py + + - name: Regenerate stubs + run: python stubs/tools/generate_stubs.py + + - name: Open or update pull request + env: + GH_TOKEN: ${{ secrets.STUBS_REFRESH_TOKEN || github.token }} + run: | + # Ignore fork PRs that happen to use the same branch name. + open_pr=$(gh pr list --head "$BRANCH" --state open --json number,isCrossRepository \ + --jq '[.[] | select(.isCrossRepository | not)][0].number // empty') + + if [ -z "$(git status --porcelain -- stubs/)" ]; then + echo "Stubs are up to date." + if [ -n "$open_pr" ]; then + gh pr close "$open_pr" --delete-branch \ + --comment "Closing this refresh PR because the generated stubs now match the default branch." + fi + exit 0 + fi + + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git switch -C "$BRANCH" + git add stubs/ + git commit -m "Refresh serpapi-stubs from the SerpApi playground" + + if [ -z "$open_pr" ]; then + # Without an open PR the remote branch is left over from a merged or closed one. Updating it + # would carry every change made to the default branch since then, and GitHub can refuse a + # push that changes workflow files that way, so start from a fresh branch. + git push --quiet origin --delete "$BRANCH" 2>/dev/null || true + fi + + # Do not rewrite the refresh branch (or rerun its checks) when it already has these stubs. + if git fetch --quiet --depth=1 origin "$BRANCH" 2>/dev/null \ + && [ "$(git rev-parse 'HEAD^{tree}')" = "$(git rev-parse 'FETCH_HEAD^{tree}')" ]; then + echo "origin/$BRANCH already has these stubs." + else + git push --force origin "$BRANCH" + fi + + { + echo "Automated weekly refresh of \`stubs/data/engines.json\` and the generated stubs." + echo + echo "Merging this PR publishes a new \`serpapi-stubs\` release when \`serpapi/\` is unchanged since the latest SDK tag; otherwise the stubs ship with the next SDK release." + echo + echo '```' + git --no-pager diff --stat HEAD~1 HEAD + echo '```' + } > "$RUNNER_TEMP/body.md" + if [ -n "$open_pr" ]; then + gh pr edit "$open_pr" --body-file "$RUNNER_TEMP/body.md" + else + gh pr create --base "${{ github.event.repository.default_branch }}" --head "$BRANCH" \ + --title "Refresh serpapi-stubs" --body-file "$RUNNER_TEMP/body.md" + fi diff --git a/.github/workflows/stubs-release.yml b/.github/workflows/stubs-release.yml new file mode 100644 index 0000000..78d8b6b --- /dev/null +++ b/.github/workflows/stubs-release.yml @@ -0,0 +1,108 @@ +name: Release serpapi-stubs + +# Publishes stub-only fixes for the current SDK release. Stub changes made alongside unreleased SDK +# changes are published by release.yml with the next SDK release instead. +on: + push: + branches: [master] + paths: + - "stubs/serpapi-stubs/**" + - "stubs/pyproject.toml" + - "stubs/MANIFEST.in" + - "stubs/LICENSE" + - "stubs/README.md" + workflow_dispatch: + +concurrency: + group: serpapi-stubs-release + cancel-in-progress: false + +permissions: + contents: read + +jobs: + guard: + name: Check SDK is released + runs-on: ubuntu-latest + outputs: + release: ${{ steps.guard.outputs.release }} + steps: + # A manual run from a release tag would otherwise republish that tag's older stubs. + - name: Require a branch + if: github.ref_type != 'branch' + run: | + echo "::error::Run this workflow from a branch, not from the ${GITHUB_REF_NAME} tag." + exit 1 + + - uses: actions/checkout@v6 + with: + fetch-depth: 0 + + - id: guard + name: Require a release branch and an unchanged, tagged SDK + env: + DEFAULT_BRANCH: ${{ github.event.repository.default_branch }} + run: | + version=$(python3 stubs/tools/release_version.py --sdk-version) + # A manual run from any other branch would publish stubs that were never merged. + if [ "$GITHUB_REF_NAME" != "$DEFAULT_BRANCH" ] && [ "$GITHUB_REF_NAME" != "stubs/hotfix-$version" ]; then + echo "::error::Release stubs from $DEFAULT_BRANCH or stubs/hotfix-$version, not from $GITHUB_REF_NAME." + exit 1 + fi + tag="v$version" + if ! git rev-parse --verify --quiet "refs/tags/$tag" >/dev/null; then + echo "::notice::$tag is not tagged yet; these stubs will ship with the SDK release." + echo "release=false" >> "$GITHUB_OUTPUT" + elif ! git diff --quiet "$tag" HEAD -- serpapi/; then + echo "::notice::serpapi/ changed since $tag; these stubs will ship with the next SDK release." + echo "release=false" >> "$GITHUB_OUTPUT" + else + echo "release=true" >> "$GITHUB_OUTPUT" + fi + + check: + needs: [guard] + if: needs.guard.outputs.release == 'true' + uses: ./.github/workflows/stubs.yml + + build: + name: Build serpapi-stubs + needs: [check] + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: Build sdist and wheel + working-directory: stubs + run: | + pip install build + python tools/release_version.py + python -m build + + - uses: actions/upload-artifact@v7 + with: + name: stubs-dist + path: stubs/dist/ + if-no-files-found: error + + publish: + name: Publish serpapi-stubs + needs: [build] + runs-on: ubuntu-latest + environment: + name: pypi-stubs + url: https://pypi.org/p/serpapi-stubs + permissions: + id-token: write + steps: + - uses: actions/download-artifact@v8 + with: + name: stubs-dist + path: dist/ + + - name: Publish to PyPI + uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml new file mode 100644 index 0000000..51680c7 --- /dev/null +++ b/.github/workflows/stubs.yml @@ -0,0 +1,61 @@ +name: serpapi-stubs + +on: + push: + branches: [master] + paths: + - "serpapi/**" + - "stubs/**" + - ".github/workflows/stubs*.yml" + pull_request: + branches: [master] + paths: + - "serpapi/**" + - "stubs/**" + - ".github/workflows/stubs*.yml" + workflow_call: + +permissions: + contents: read + +jobs: + check: + name: Check stubs + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: Install tools + run: pip install build pytest "mypy==2.4.1" "pyright==1.1.414" + + - name: Check generated stubs are current + run: python stubs/tools/generate_stubs.py --check + + - name: Test stub tooling + working-directory: stubs + run: python -m pytest + + - name: Build stub distribution + working-directory: stubs + run: | + python tools/release_version.py --offline + python -m build + + - name: Install SDK and stubs + run: pip install . stubs/dist/*.whl + + - name: Compare stubs with the runtime SDK + working-directory: stubs + run: python -m mypy.stubtest serpapi --allowlist tests/stubtest_allowlist.txt + + - name: Type-check usage samples with mypy + working-directory: stubs + run: mypy + + - name: Type-check usage samples with pyright + working-directory: stubs + run: pyright diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 74afa96..6adce44 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -170,14 +170,58 @@ Use GitHub Actions to request builds after this setup. A manual RTD build has no See the [RTD build API](https://docs.readthedocs.com/platform/stable/api/v3.html#build-triggering), [Git integration settings](https://docs.readthedocs.com/platform/stable/reference/git-integration.html), and [GitHub environment settings](https://docs.github.com/en/actions/how-tos/deploy/configure-and-manage-deployments/manage-environments) for the platform setup details. +## Type stubs + +The `stubs/` directory builds `serpapi-stubs`, a separate PyPI distribution that users install with `pip install "serpapi[typing]"`. The SDK wheel and source distribution do not include it. See [stubs/README.md](stubs/README.md) for the layout and the commands that refresh and regenerate the stubs. + +The [stubs workflow](.github/workflows/stubs.yml) runs on pull requests that change `serpapi/` or `stubs/`. To run the same checks locally, install the stubs into your development environment and type-check the samples: + +```sh +cd stubs +python tools/generate_stubs.py --check +python -m pytest +python tools/release_version.py --offline +uv build --clear +uv pip install mypy pyright --reinstall-package serpapi-stubs dist/*.whl +python -m mypy.stubtest serpapi --allowlist tests/stubtest_allowlist.txt +mypy +pyright +``` + +`release_version.py` writes the ignored `VERSION` file that the build reads. Stub versions are computed in CI, so never set them by hand. Stubtest fails when a public SDK function or class changes without a matching stub change, so update the handwritten stubs in `stubs/serpapi-stubs/` together with the SDK. + +### Stub releases + +Stubs are published in two ways: + +- **With an SDK release.** The release workflow publishes `serpapi-stubs` `.` before it publishes the SDK, so `serpapi[typing]` resolves as soon as the SDK is available. +- **Between SDK releases.** When a push to `master` changes the shipped stub files, the [stub release workflow](.github/workflows/stubs-release.yml) publishes a new version for the current SDK release. It skips publishing if `serpapi/__version__.py` names a version that has not been tagged or if `serpapi/` changed since that tag. Those stubs ship with the next SDK release instead. + +The [refresh workflow](.github/workflows/stubs-refresh.yml) runs every Monday. It fetches the engine metadata, regenerates the stubs, and opens or updates a pull request from `bot/refresh-serpapi-stubs` when anything changed. If a later run finds that the stubs match `master` again, it closes that pull request. A manual run also refreshes from `master`, whichever branch it is started on. Review the diff before merging: merging usually publishes a stub release. + +GitHub can refuse a push that carries workflow-file changes from `master` into an existing branch. The workflow avoids that by recreating a leftover refresh branch, but it cannot do so while the refresh pull request is open. If a run fails to push for that reason, merge or close the pull request and run the workflow again. + +If a stub release breaks valid code, yank it on PyPI and merge a fix. The SDK-tag workflow publishes a stub series only once, so rerunning an old SDK tag cannot supersede a newer stub-only release with the tag's older stub files. For an upload collision between simultaneous stub releases, choose **Re-run all jobs** on the stub-only release workflow. It computes the next available date suffix, whereas **Re-run failed jobs** reuses the colliding version. + +The stub version scheme currently supports final numeric SDK versions only, such as `1.2.3`. Prerelease, post-release, and development SDK versions cannot be published with the `serpapi-stubs` date suffix or the `serpapi[typing]` exact-series pin. + +If a stub fix is needed after `serpapi/` has changed for an unreleased SDK version, the automatic workflow correctly skips it. To hotfix the released SDK, create a compatibility branch from its tag, bring over only the corrected `stubs/` content and the current `stubs.yml` and `stubs-release.yml` workflows, and keep `serpapi/` unchanged from the tag. Push it as `stubs/hotfix-` and manually run **Release serpapi-stubs** on that branch; the workflow only runs from `master` or from the hotfix branch named after the SDK version it contains. Add `stubs/hotfix-*` as an allowed branch for the `pypi-stubs` environment before dispatching. + +### Stub maintainer setup + +1. On PyPI, add a [pending trusted publisher](https://docs.pypi.org/trusted-publishers/creating-a-project-through-oidc/) for the `serpapi-stubs` project with owner `serpapi`, repository `serpapi-python`, workflow `stubs-release.yml`, and environment `pypi-stubs`. After the first upload creates the project, add a second trusted publisher with workflow `release.yml` and the same environment under the project's **Publishing** settings. +2. In GitHub **Settings > Environments**, create an environment named `pypi-stubs`. Under **Deployment branches and tags**, add Branch rules for `master` and `stubs/hotfix-*`, and a Tag rule for `v*`. +3. In **Settings > Actions > General**, enable **Allow GitHub Actions to create and approve pull requests** so the refresh workflow can open its pull request. Pull requests opened with the default `GITHUB_TOKEN` do not start other workflows. To run the stub checks on them automatically, add a repository secret named `STUBS_REFRESH_TOKEN` containing a fine-grained token with **Contents** and **Pull requests** write access to this repository. +4. After merging these changes, the stub release workflow publishes the first `serpapi-stubs` release for the current SDK version. If it ran before the setup was complete, run **Release serpapi-stubs** manually on `master`. + ## Publishing a new release -1. Update the version in `serpapi/__version__.py`. +1. Update the version in `serpapi/__version__.py` and the `serpapi-stubs` pin of the `typing` extra in `pyproject.toml` to match, for example `serpapi-stubs==1.2.3.*`. `tests/test_typing_extra.py` fails if they differ. 2. Push a tag for that version. The release pipeline runs automatically: ```sh git tag v1.2.3 git push origin v1.2.3 ``` - This triggers the [release workflow](.github/workflows/release.yml), which tests, builds, and publishes to PyPI, then smoke-tests the published package. + This triggers the [release workflow](.github/workflows/release.yml), which tests and builds the SDK and stubs, publishes `serpapi-stubs` and then `serpapi` to PyPI, and smoke-tests the published package. If the stub checks or upload fail, the SDK is not published. The workflow also fails before publishing anything if the tag is not `v` followed by the version in `serpapi/__version__.py`. > **Required secret:** `API_KEY` (used by the live documentation examples and the published-package smoke test). diff --git a/README.md b/README.md index aa061f2..2b30497 100644 --- a/README.md +++ b/README.md @@ -17,6 +17,18 @@ To install the `serpapi` package, simply run the following command inside your P pip install serpapi ``` +To add engine-specific type hints for mypy, pyright, and IDEs, install the `typing` extra. It installs [`serpapi-stubs`](https://github.com/serpapi/serpapi-python/tree/master/stubs), a typing-only package versioned with the SDK: + +```bash +pip install "serpapi[typing]" +``` + +SDK 1.2.0 was released before the `typing` extra. To use the stubs with it, install them directly: + +```bash +pip install "serpapi-stubs==1.2.0.*" +``` + ## Quickstart [Create a SerpApi account](https://serpapi.com/users/sign_up?plan=free) to get your API key, then store it in an environment variable: diff --git a/docs/examples/google-images-search.md b/docs/examples/google-images-search.md index f9a8e1d..d9e6eef 100644 --- a/docs/examples/google-images-search.md +++ b/docs/examples/google-images-search.md @@ -18,11 +18,7 @@ import serpapi client = serpapi.Client(api_key=os.environ["SERPAPI_KEY"], timeout=20) -results = client.search( - engine="google_images", - tbm="isch", - q="coffee", -) +results = client.search({"engine": "google_images", "tbm": "isch", "q": "coffee"}) for image in results.get("images_results", [])[:5]: print(image.get("title")) diff --git a/docs/examples/google-lens-image-upload.md b/docs/examples/google-lens-image-upload.md index 0f1dcf6..63a0ac5 100644 --- a/docs/examples/google-lens-image-upload.md +++ b/docs/examples/google-lens-image-upload.md @@ -41,4 +41,4 @@ for match in results.get("visual_matches", [])[:5]: Read matching images and pages from `visual_matches`. Each match can include a `title`, `source`, `link`, and `thumbnail`. The example prints up to five matches and prints nothing if that list is empty. -Set `type="products"` to look for products, or `type="exact_matches"` to find pages containing the same image. See the [Google Lens API documentation](https://serpapi.com/google-lens-api) for search types and other parameters. +Set `type="exact_matches"` to find pages containing the same image. See the [Google Lens API documentation](https://serpapi.com/google-lens-api) for search types and other parameters. diff --git a/docs/examples/google-play-store-apps.md b/docs/examples/google-play-store-apps.md index f60fc35..a0ae87b 100644 --- a/docs/examples/google-play-store-apps.md +++ b/docs/examples/google-play-store-apps.md @@ -19,10 +19,7 @@ import serpapi client = serpapi.Client(api_key=os.environ["SERPAPI_KEY"], timeout=20) results = client.search( - engine="google_play", - q="kite", - store="apps", - max_results="2", + {"engine": "google_play", "q": "kite", "store": "apps", "max_results": "2"} ) for app in results.get("organic_results", [])[:5]: diff --git a/docs/user_guide/async-search-archive.md b/docs/user_guide/async-search-archive.md index 206cbd8..2091ca6 100644 --- a/docs/user_guide/async-search-archive.md +++ b/docs/user_guide/async-search-archive.md @@ -11,14 +11,11 @@ Create a client as shown in the [client usage guide](client-usage.md#create-a-cl ## Submit an async search -`async` is a reserved word in Python. Put it in a dictionary and use `**` to pass that dictionary's entries as keyword arguments: +`async` is a reserved word in Python. Pass it in the parameter dictionary: ```python submitted = client.search( - engine="google", - q="coffee", - location="Austin, Texas", - **{"async": True}, + {"engine": "google", "q": "coffee", "location": "Austin, Texas", "async": True}, timeout=30, ) diff --git a/pyproject.toml b/pyproject.toml index 73c7799..ae663ac 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -41,6 +41,7 @@ classifiers = [ [project.optional-dependencies] color = ["pygments"] test = ["pytest"] +typing = ["serpapi-stubs==1.2.0.*"] docs = [ "sphinx>=8.2,<9; python_version >= '3.11'", "myst-parser>=4,<5; python_version >= '3.11'", diff --git a/stubs/.gitignore b/stubs/.gitignore new file mode 100644 index 0000000..8d59dcd --- /dev/null +++ b/stubs/.gitignore @@ -0,0 +1,4 @@ +VERSION +build/ +dist/ +*.egg-info/ diff --git a/stubs/LICENSE b/stubs/LICENSE new file mode 100644 index 0000000..ed10fe2 --- /dev/null +++ b/stubs/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018-2023 SerpApi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/stubs/MANIFEST.in b/stubs/MANIFEST.in new file mode 100644 index 0000000..468a9d0 --- /dev/null +++ b/stubs/MANIFEST.in @@ -0,0 +1,2 @@ +include VERSION +prune tests diff --git a/stubs/README.md b/stubs/README.md new file mode 100644 index 0000000..92fb16e --- /dev/null +++ b/stubs/README.md @@ -0,0 +1,99 @@ +# serpapi-stubs + +Type stubs for [`serpapi`](https://pypi.org/project/serpapi/), the official SerpApi Python client. They describe the parameters of every SerpApi engine, so mypy, pyright, and IDEs can autocomplete parameter names and flag typos or invalid option values before a request is sent. + +The stubs are typing-only. They do not change runtime behavior. + +## Installation + +Install them through the SDK's `typing` extra: + +```sh +pip install "serpapi[typing]" +``` + +The extra installs the newest stubs built for the installed SDK version. + +SDK 1.2.0 was released before the extra existed, so pip ignores `[typing]` there and warns that the extra does not exist. Install its stubs directly: + +```sh +pip install "serpapi-stubs==1.2.0.*" +``` + +Stubs are not published for SDK versions older than 1.2.0. + +## Usage + +Keyword arguments are checked against the selected engine: + +```python +import serpapi + +client = serpapi.Client(api_key="...") +client.search(engine="google", q="coffee", device="mobile") # OK +client.search(engine="google", q="coffee", locaton="Austin") # error: unexpected keyword "locaton" +client.search(engine="google", q="coffee", device="watch") # error: invalid option +html = client.search(engine="bing", q="coffee", output="html") # str, not SerpResults +``` + +A plain dict is accepted as before. Its keys are checked only when you annotate it with a parameter type from `serpapi.engine_params`. That module exists only for type checkers, so import it under `TYPE_CHECKING`: + +```python +from typing import TYPE_CHECKING + +if TYPE_CHECKING: + from serpapi.engine_params import GoogleJsonSearchParams + +params: "GoogleJsonSearchParams" = {"engine": "google", "q": "coffee"} +results = client.search(params) +``` + +Each engine has `JsonSearchParams`, `TextSearchParams` (for `output="html"` or `"md"`), and their union `SearchParams`. `SearchParams` covers every engine. Extract and the Search Archive use `ExtractParams` and `SearchArchiveParams`. + +Notes: + +- `async` and `from` are Python keywords, so pass them in the params dict: `client.search({"engine": "google", "q": "coffee", "async": True})`. +- In keyword calls, `timeout` is the HTTP request timeout. Pass Extract's API `timeout` parameter in the params dict. +- Keyword calls need literal `engine` and `output` values so the checker can select the engine's overload. A `str` variable, or `**` unpacking of a `Dict[str, str]`, is rejected. When either value is computed at runtime, pass a params dict, or type the value as `Literal` or `Final`. +- `search()`, `search_archive()`, `locations()`, and `account()` write the API key into the mapping they receive, so pass a `dict` or a `serpapi.engine_params` type. A read-only `Mapping` or your own `TypedDict` is rejected; pass `dict(params)` instead. `extract()` copies its mapping and accepts any `Mapping`. +- Pyright reports `reportMissingModuleSource` for `serpapi.engine_params` because the module has no runtime source. Importing it under `TYPE_CHECKING` is safe. + +Engine parameters come from the [SerpApi Playground](https://serpapi.com/playground). Parameters that SerpApi has not documented there are reported as errors. Use a `# type: ignore` comment or an untyped `dict` if you need one. Parameters that the Playground gives no type accept `str`, `int`, or `float`, because the SDK sends numbers as text. + +The Playground sometimes uses UI-specific values rather than the API values (for example, Amazon language choices combine a domain and locale). The stubs normalize those choices to the API's documented locale codes. A parameter is typed as a closed set of options only when the Playground presents it as a single-choice list whose spelling matches its documentation. Parameters that document case-insensitive values (such as Bing's `mkt`, `cc`, and `safeSearch`) or comma-separated values (such as Tripadvisor Reviews' `type_of_visit`) are typed `str`. When an engine parameter is not present in the Playground, pass a mapping to `search()`; mapping calls remain compatible with runtime-supported parameters without weakening keyword checks. + +## Versions + +Stub versions use the SDK version they describe, followed by the release date: `1.2.0.20260715` contains stubs for `serpapi` 1.2.0 published on 2026-07-15. A second release on the same day adds a counter, such as `1.2.0.20260715.1`. + +Stub releases currently support final numeric SDK versions only (`X.Y.Z`). Prerelease, post-release, and development SDK versions are not supported by the stub versioning scheme or its exact-series extra pin. + +`serpapi[typing]` requires `serpapi-stubs==.*`, so you get stub updates for your SDK version only. New stubs are published with each SDK release and whenever parameter metadata changes between SDK releases. + +A stub update can add, remove, or narrow parameters as SerpApi engines change. That can make code that passed type checking fail it, but runtime behavior never changes. To control when you take these updates, pin the stubs alongside the extra or use a lockfile: + +```sh +pip install "serpapi[typing]" "serpapi-stubs==1.2.0.20260715" +``` + +A stub release that breaks valid code is yanked from PyPI and fixed in a newer release. If a fix is needed after `serpapi/` has changed for an unreleased SDK version, prepare a compatibility hotfix branch from the affected SDK tag. Bring over the corrected `stubs/` files and the current `stubs.yml` and `stubs-release.yml` workflows, but keep `serpapi/` identical to the tag. Push the branch as `stubs/hotfix-` and manually run **Release serpapi-stubs** on that branch. Add the `stubs/hotfix-*` branch rule to the `pypi-stubs` environment before dispatching; the workflow still verifies that the branch name and the SDK source match the tag. + +## Development + +The stubs are built from the [`stubs/`](https://github.com/serpapi/serpapi-python/tree/master/stubs) directory of the SDK repository: + +- `data/engines.json`: engine metadata collected from the SerpApi Playground. +- `serpapi-stubs/core.pyi` and `serpapi-stubs/engine_params.pyi`: generated from the snapshot. Do not edit them by hand. +- `serpapi-stubs/*.pyi`: the other stubs, maintained by hand. +- `tools/`: the fetcher, the generator, and the release version script. + +Run these commands from the `stubs/` directory: + +```sh +python tools/fetch_engines.py # refresh data/engines.json +python tools/generate_stubs.py # regenerate the generated stubs +python tools/generate_stubs.py --check # fail if the generated stubs are stale +python -m pytest # test the tooling +``` + +A scheduled workflow refreshes the snapshot every week and opens a pull request when it changes. CI also compares the stubs with the runtime SDK using `mypy.stubtest` and type-checks the samples in `tests/typecheck` with mypy and pyright. See the [contributing guide](https://github.com/serpapi/serpapi-python/blob/master/CONTRIBUTING.md#type-stubs) for the release process. diff --git a/stubs/data/engines.json b/stubs/data/engines.json new file mode 100644 index 0000000..99cee34 --- /dev/null +++ b/stubs/data/engines.json @@ -0,0 +1,10202 @@ +{ + "source": "https://serpapi.com/playground", + "engines": { + "airbnb": { + "accessibility_features": {}, + "adults": { + "type": "number" + }, + "airbnb_domain": { + "type": "select", + "value_type": "string" + }, + "amenities": {}, + "api_key": { + "required": true + }, + "async": {}, + "bathrooms": { + "type": "number" + }, + "bedrooms": { + "type": "number" + }, + "beds": { + "type": "number" + }, + "check_in_date": {}, + "check_out_date": {}, + "children": { + "type": "number" + }, + "currency": { + "type": "select", + "options": [ + "AED", + "ARS", + "AUD", + "AWG", + "BAM", + "BBD", + "BGN", + "BHD", + "BND", + "BRL", + "BTN", + "BZD", + "CAD", + "CHF", + "CLP", + "CNY", + "COP", + "CRC", + "CZK", + "DKK", + "EGP", + "EUR", + "FJD", + "GBP", + "GHS", + "GTQ", + "GYD", + "HKD", + "HNL", + "HRK", + "HUF", + "IDR", + "ILS", + "INR", + "JMD", + "JOD", + "JPY", + "KES", + "KRW", + "KZT", + "LAK", + "LKR", + "MAD", + "MOP", + "MXN", + "MYR", + "NOK", + "NZD", + "OMR", + "PEN", + "PGK", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "SEK", + "SGD", + "THB", + "TRY", + "TTD", + "TWD", + "UAH", + "UGX", + "USD", + "UYU", + "VND", + "ZAR" + ] + }, + "engine": { + "required": true + }, + "guest_favorite": { + "type": "checkbox" + }, + "host_languages": {}, + "infants": { + "type": "number" + }, + "instant_book": { + "type": "checkbox" + }, + "json_restrictor": {}, + "luxe": { + "type": "checkbox" + }, + "map_bounds": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "pets": { + "type": "number" + }, + "property_types": {}, + "q": {}, + "room_type": { + "type": "select", + "options": [ + "entire_home", + "private_room" + ] + }, + "self_check_in": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "amazon": { + "amazon_domain": { + "type": "select", + "options": [ + "amazon.com.au", + "amazon.com.be", + "amazon.com.br", + "amazon.ca", + "amazon.cn", + "amazon.eg", + "amazon.fr", + "amazon.de", + "amazon.in", + "amazon.it", + "amazon.co.jp", + "amazon.nl", + "amazon.pl", + "amazon.sa", + "amazon.sg", + "amazon.es", + "amazon.se", + "amazon.com.tr", + "amazon.ae", + "amazon.co.uk", + "amazon.com", + "amazon.com.mx" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "dc": { + "type": "checkbox" + }, + "delivery_city": {}, + "delivery_zip": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "emi": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "k": {}, + "language": { + "type": "select", + "options": [ + "en_AU", + "nl_BE", + "fr_BE", + "en_GB", + "pt_BR", + "en_CA", + "fr_CA", + "zh_CN", + "ar_AE", + "en_AE", + "fr_FR", + "de_DE", + "cs_CZ", + "nl_NL", + "pl_PL", + "tr_TR", + "da_DK", + "en_IN", + "hi_IN", + "ta_IN", + "te_IN", + "kn_IN", + "ml_IN", + "bn_IN", + "mr_IN", + "it_IT", + "ja_JP", + "en_US", + "en_SG", + "es_ES", + "pt_PT", + "sv_SE", + "es_US", + "es_MX" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "node": {}, + "output": {}, + "page": { + "type": "number" + }, + "rh": {}, + "s": { + "type": "select", + "options": [ + "relevanceblender", + "price-asc-rank", + "price-desc-rank", + "review-rank", + "date-desc-rank", + "exact-aware-popularity-rank" + ] + }, + "shipping_location": { + "type": "select", + "value_type": "string" + }, + "zero_trace": {} + }, + "amazon_autocomplete": { + "amazon_department": { + "type": "select", + "options": [ + "aps", + "alexa-skills", + "vehicles", + "amazon-devices", + "amazonfresh", + "amazon-global-store", + "bazaar", + "amazon-one-medical", + "amazon-pharmacy", + "warehouse-deals", + "appliances", + "mobile-apps", + "arts-crafts", + "audible", + "automotive", + "baby-products", + "beauty", + "stripbooks", + "popular", + "mobile", + "fashion", + "fashion-womens", + "fashion-mens", + "fashion-girls", + "fashion-boys", + "fashion-baby", + "collectibles", + "computers", + "financial", + "digital-music", + "electronics", + "lawngarden", + "gift-cards", + "grocery", + "handmade", + "hpc", + "local-services", + "garden", + "industrial", + "prime-exclusive", + "digital-text", + "fashion-luggage", + "luxury", + "magazines", + "movies-tv", + "mi", + "office-products", + "pets", + "luxury-beauty", + "instant-video", + "samedaystore", + "smart-home", + "software", + "sporting", + "specialty-aps-sns", + "subscribe-with-amazon", + "tools", + "toys-and-games", + "under-ten-dollars", + "videogames", + "vons", + "wholefoods" + ] + }, + "amazon_domain": { + "type": "select", + "options": [ + "amazon.com.au", + "amazon.com.be", + "amazon.com.br", + "amazon.ca", + "amazon.cn", + "amazon.eg", + "amazon.fr", + "amazon.de", + "amazon.in", + "amazon.it", + "amazon.co.jp", + "amazon.nl", + "amazon.pl", + "amazon.sa", + "amazon.sg", + "amazon.es", + "amazon.se", + "amazon.com.tr", + "amazon.ae", + "amazon.co.uk", + "amazon.com", + "amazon.com.mx" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "k": { + "required": true + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "amazon_fresh": { + "amazon_domain": { + "type": "select", + "options": [ + "amazon.it", + "amazon.co.jp", + "amazon.es", + "amazon.co.uk", + "amazon.com" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "dc": { + "type": "checkbox" + }, + "delivery_zip": { + "required": true + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "k": {}, + "language": { + "type": "select", + "options": [ + "it_IT", + "en_GB", + "ja_JP", + "en_US", + "zh_CN", + "es_ES", + "pt_PT", + "es_US" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "node": {}, + "output": {}, + "page": { + "type": "number" + }, + "rh": {}, + "s": { + "type": "select", + "options": [ + "relevanceblender", + "price-asc-rank", + "price-desc-rank", + "review-rank", + "date-desc-rank", + "exact-aware-popularity-rank" + ] + }, + "zero_trace": {} + }, + "amazon_product": { + "all_related_products": { + "type": "checkbox" + }, + "amazon_domain": { + "type": "select", + "options": [ + "amazon.com.au", + "amazon.com.be", + "amazon.com.br", + "amazon.ca", + "amazon.cn", + "amazon.eg", + "amazon.fr", + "amazon.de", + "amazon.in", + "amazon.it", + "amazon.co.jp", + "amazon.nl", + "amazon.pl", + "amazon.sa", + "amazon.sg", + "amazon.es", + "amazon.se", + "amazon.com.tr", + "amazon.ae", + "amazon.co.uk", + "amazon.com", + "amazon.com.mx" + ] + }, + "api_key": { + "required": true + }, + "asin": { + "required": true + }, + "async": {}, + "delivery_city": {}, + "delivery_zip": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "en_AU", + "nl_BE", + "fr_BE", + "en_GB", + "pt_BR", + "en_CA", + "fr_CA", + "zh_CN", + "ar_AE", + "en_AE", + "fr_FR", + "de_DE", + "cs_CZ", + "nl_NL", + "pl_PL", + "tr_TR", + "da_DK", + "en_IN", + "hi_IN", + "ta_IN", + "te_IN", + "kn_IN", + "ml_IN", + "bn_IN", + "mr_IN", + "it_IT", + "ja_JP", + "en_US", + "en_SG", + "es_ES", + "pt_PT", + "sv_SE", + "es_US", + "es_MX" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "other_sellers": { + "type": "checkbox" + }, + "output": {}, + "shipping_location": { + "type": "select", + "value_type": "string" + }, + "zero_trace": {} + }, + "amazon_promotion": { + "amazon_domain": { + "type": "select", + "options": [ + "amazon.com.au", + "amazon.com.be", + "amazon.com.br", + "amazon.ca", + "amazon.eg", + "amazon.fr", + "amazon.de", + "amazon.in", + "amazon.it", + "amazon.co.jp", + "amazon.nl", + "amazon.pl", + "amazon.sa", + "amazon.sg", + "amazon.es", + "amazon.se", + "amazon.com.tr", + "amazon.ae", + "amazon.co.uk", + "amazon.com", + "amazon.com.mx" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "include_products": { + "type": "checkbox" + }, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "en_AU", + "nl_BE", + "fr_BE", + "en_GB", + "pt_BR", + "en_CA", + "fr_CA", + "ar_AE", + "en_AE", + "fr_FR", + "de_DE", + "cs_CZ", + "nl_NL", + "pl_PL", + "tr_TR", + "da_DK", + "en_IN", + "hi_IN", + "ta_IN", + "te_IN", + "kn_IN", + "ml_IN", + "bn_IN", + "mr_IN", + "it_IT", + "ja_JP", + "en_US", + "zh_CN", + "en_SG", + "es_ES", + "pt_PT", + "sv_SE", + "es_US", + "es_MX" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "promotion_id": { + "required": true + }, + "zero_trace": {} + }, + "apple_app_store": { + "api_key": { + "required": true + }, + "async": {}, + "category_id": { + "type": "select", + "value_type": "number" + }, + "country": { + "type": "select", + "value_type": "string" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "disallow_explicit": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lang": { + "type": "select", + "options": [ + "pt-br", + "it-it", + "hi-in", + "ca-es", + "es-es", + "zh-tw", + "th-th", + "da-dk", + "fi-fi", + "en-gb", + "nl-nl", + "pl-pl", + "ro-ro", + "zh-cn", + "no-no", + "pt-pt", + "de-ch", + "uk-ua", + "en-us", + "vi-vi", + "sv-se", + "en-ca", + "fr-fr", + "sk-sk", + "zh-hk", + "hr-hr", + "en-au", + "ko-kr", + "tr-tr", + "el-gr", + "ms-my", + "id-id", + "cs-cz", + "hu-hu", + "fr-ca", + "es-mx", + "de-de", + "ru-ru", + "ja-jp" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "property": { + "type": "select", + "options": [ + "developer" + ] + }, + "term": { + "required": true + }, + "zero_trace": {} + }, + "apple_maps": { + "api_key": { + "required": true + }, + "async": {}, + "center": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "locale": { + "type": "select", + "options": [ + "ar-SA", + "bn-BD", + "ca-ES", + "cs-CZ", + "da-DK", + "de-DE", + "el-GR", + "en-AU", + "en-GB", + "en-US", + "es-ES", + "es-MX", + "fi-FI", + "fr-CA", + "fr-FR", + "gu-IN", + "he-IL", + "hi-IN", + "hr-HR", + "hu-HU", + "id-ID", + "it-IT", + "ja-JP", + "kn-IN", + "ko-KR", + "ml-IN", + "mr-IN", + "ms-MY", + "nb-NO", + "nl-NL", + "or-IN", + "pa-IN", + "pl-PL", + "pt-BR", + "pt-PT", + "ro-RO", + "ru-RU", + "sk-SK", + "sl-SI", + "sv-SE", + "ta-IN", + "te-IN", + "th-TH", + "tr-TR", + "uk-UA", + "ur-PK", + "vi-VN", + "zh-CN", + "zh-HK", + "zh-TW" + ] + }, + "location": { + "type": "location" + }, + "multi_select_options": {}, + "no_cache": { + "type": "checkbox" + }, + "open_at": { + "type": "number" + }, + "output": {}, + "query": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "default", + "distance", + "ratings" + ] + }, + "span": {}, + "toggles": {}, + "zero_trace": {} + }, + "apple_maps_places": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "locale": { + "type": "select", + "options": [ + "ar-SA", + "bn-BD", + "ca-ES", + "cs-CZ", + "da-DK", + "de-DE", + "el-GR", + "en-AU", + "en-GB", + "en-US", + "es-ES", + "es-MX", + "fi-FI", + "fr-CA", + "fr-FR", + "gu-IN", + "he-IL", + "hi-IN", + "hr-HR", + "hu-HU", + "id-ID", + "it-IT", + "ja-JP", + "kn-IN", + "ko-KR", + "ml-IN", + "mr-IN", + "ms-MY", + "nb-NO", + "nl-NL", + "or-IN", + "pa-IN", + "pl-PL", + "pt-BR", + "pt-PT", + "ro-RO", + "ru-RU", + "sk-SK", + "sl-SI", + "sv-SE", + "ta-IN", + "te-IN", + "th-TH", + "tr-TR", + "uk-UA", + "ur-PK", + "vi-VN", + "zh-CN", + "zh-HK", + "zh-TW" + ] + }, + "muid": { + "required": true + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "apple_product": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "value_type": "string" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "type": { + "type": "select", + "options": [ + "app" + ] + }, + "zero_trace": {} + }, + "apple_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "value_type": "string" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "product_id": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "mostrecent", + "mosthelpful", + "mostfavorable", + "mostcritical" + ] + }, + "zero_trace": {} + }, + "autozone": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "facet": {}, + "include_filters": { + "type": "checkbox" + }, + "json_restrictor": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "ps": { + "type": "number" + }, + "q": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "featured", + "price_low", + "price_high", + "recently_added", + "rating_high", + "best_seller" + ] + }, + "store_id": {}, + "vehicle_engine": {}, + "vehicle_make": {}, + "vehicle_model": {}, + "vehicle_submodel": {}, + "vehicle_type": { + "type": "select", + "options": [ + "car_truck", + "motorcycle", + "recreational" + ] + }, + "vehicle_year": {}, + "zero_trace": {} + }, + "autozone_product": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "store_id": {}, + "vehicle_engine": {}, + "vehicle_make": {}, + "vehicle_model": {}, + "vehicle_submodel": {}, + "vehicle_token": {}, + "vehicle_type": { + "type": "select", + "options": [ + "car_truck", + "motorcycle", + "recreational" + ] + }, + "vehicle_year": {}, + "zero_trace": {} + }, + "baidu": { + "api_key": { + "required": true + }, + "async": {}, + "bs": {}, + "ct": { + "type": "select", + "value_type": "number" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "f": {}, + "gpc": {}, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "oq": {}, + "output": {}, + "pn": { + "type": "number" + }, + "q": { + "required": true + }, + "q5": {}, + "q6": {}, + "rn": { + "type": "number" + }, + "zero_trace": {} + }, + "baidu_maps": { + "api_key": { + "required": true + }, + "async": {}, + "c": { + "type": "select", + "value_type": "number" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "zero_trace": {} + }, + "baidu_news": { + "api_key": { + "required": true + }, + "async": {}, + "ct": { + "type": "select", + "value_type": "number" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "medium": { + "type": "select", + "value_type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "pn": { + "type": "number" + }, + "q": { + "required": true + }, + "rn": { + "type": "number" + }, + "rtt": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "bing": { + "api_key": { + "required": true + }, + "async": {}, + "cc": { + "type": "select", + "value_type": "string" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filters": {}, + "first": { + "type": "number" + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "mkt": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safeSearch": { + "type": "select", + "value_type": "string" + }, + "zero_trace": {} + }, + "bing_copilot": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "bing_images": { + "age": { + "type": "select", + "options": [ + "lt1440", + "lt10080", + "lt43200", + "lt525600" + ] + }, + "api_key": { + "required": true + }, + "aspect": { + "type": "select", + "options": [ + "square", + "wide", + "tall" + ] + }, + "async": {}, + "cc": { + "type": "select", + "value_type": "string" + }, + "color2": { + "type": "select", + "options": [ + "color", + "bw", + "FGcls_RED", + "FGcls_ORANGE", + "FGcls_YELLOW", + "FGcls_GREEN", + "FGcls_TEAL", + "FGcls_BLUE", + "FGcls_PURPLE", + "FGcls_PINK", + "FGcls_BROWN", + "FGcls_BLACK", + "FGcls_GRAY", + "FGcls_WHITE" + ] + }, + "count": { + "type": "number" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "face": { + "type": "select", + "options": [ + "face", + "portrait" + ] + }, + "first": { + "type": "number" + }, + "imagesize": { + "type": "select", + "options": [ + "small", + "medium", + "large", + "wallpaper" + ] + }, + "json_restrictor": {}, + "license": { + "type": "select", + "options": [ + "Type-Any", + "L1", + "L2_L3_L4_L5_L6_L7", + "L2_L3_L4", + "L2_L3_L5_L6", + "L2_L3" + ] + }, + "mkt": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "photo": { + "type": "select", + "options": [ + "photo", + "clipart", + "linedrawing", + "animatedgif", + "animatedgifhttps", + "transparent", + "shopping" + ] + }, + "q": { + "required": true + }, + "safeSearch": { + "type": "select", + "options": [ + "strict", + "moderate", + "off" + ] + }, + "zero_trace": {} + }, + "bing_maps": { + "api_key": { + "required": true + }, + "async": {}, + "count": { + "type": "number" + }, + "cp": {}, + "engine": { + "required": true + }, + "first": { + "type": "number" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "place_id": {}, + "q": { + "required": true + }, + "setlang": { + "type": "select", + "options": [ + "ar", + "eu", + "bn", + "bg", + "ca", + "zh-hans", + "zh-hant", + "hr", + "cs", + "da", + "nl", + "en", + "en-gb", + "et", + "fi", + "fr", + "gl", + "de", + "gu", + "he", + "hi", + "hu", + "is", + "it", + "jp", + "kn", + "ko", + "lv", + "lt", + "ms", + "ml", + "mr", + "nb", + "pl", + "pt-br", + "pt-pt", + "pa", + "ro", + "ru", + "sr", + "sk", + "sl", + "es", + "sv", + "ta", + "te", + "th", + "tr", + "uk", + "vi" + ] + }, + "zero_trace": {} + }, + "bing_news": { + "api_key": { + "required": true + }, + "async": {}, + "cc": { + "type": "select", + "value_type": "string" + }, + "count": { + "type": "number" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "first": { + "type": "number" + }, + "json_restrictor": {}, + "mkt": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "qft": { + "type": "select", + "options": [ + "interval=\"4\"", + "interval=\"7\"", + "interval=\"8\"", + "interval=\"9\"", + "sortbydate=\"1\"" + ] + }, + "safeSearch": { + "type": "select", + "value_type": "string" + }, + "zero_trace": {} + }, + "bing_product": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_token": { + "required": true + }, + "zero_trace": {} + }, + "bing_reverse_image": { + "api_key": { + "required": true + }, + "async": {}, + "cab": { + "type": "number" + }, + "cal": { + "type": "number" + }, + "car": { + "type": "number" + }, + "cat": { + "type": "number" + }, + "count": { + "type": "number" + }, + "engine": { + "required": true + }, + "image_url": { + "required": true + }, + "json_restrictor": {}, + "mkt": { + "type": "select", + "value_type": "string" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "bing_shopping": { + "api_key": { + "required": true + }, + "async": {}, + "cc": { + "type": "select", + "value_type": "string" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "efirst": { + "type": "number" + }, + "engine": { + "required": true + }, + "filters": {}, + "json_restrictor": {}, + "mkt": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "bing_videos": { + "api_key": { + "required": true + }, + "async": {}, + "cc": { + "type": "select", + "value_type": "string" + }, + "date": { + "type": "select", + "options": [ + "lt1440", + "lt10080", + "lt43200", + "lt525600" + ] + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "first": { + "type": "number" + }, + "json_restrictor": {}, + "length": { + "type": "select", + "options": [ + "short", + "medium", + "long" + ] + }, + "mkt": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "price": { + "type": "select", + "options": [ + "free", + "paid" + ] + }, + "q": { + "required": true + }, + "resolution": { + "type": "select", + "options": [ + "lowerthan_360p", + "360p", + "480p", + "720p", + "1080p" + ] + }, + "setlang": { + "type": "select", + "options": [ + "ar", + "eu", + "bn", + "bg", + "ca", + "zh-hans", + "zh-hant", + "hr", + "cs", + "da", + "nl", + "en", + "en-gb", + "et", + "fi", + "fr", + "gl", + "de", + "gu", + "he", + "hi", + "hu", + "is", + "it", + "jp", + "kn", + "ko", + "lv", + "lt", + "ms", + "ml", + "mr", + "nb", + "pl", + "pt-br", + "pt-pt", + "pa", + "ro", + "ru", + "sr", + "sk", + "sl", + "es", + "sv", + "ta", + "te", + "th", + "tr", + "uk", + "vi" + ] + }, + "source_site": { + "type": "select", + "options": [ + "dailymotion.com", + "vimeo.com", + "metacafe.com", + "hulu.com", + "vevo.com", + "myspace.com", + "mtv.com", + "cbsnews.com", + "foxnews.com", + "cnn.com", + "msn.com" + ] + }, + "zero_trace": {} + }, + "booking": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "check_in_date": {}, + "check_out_date": {}, + "children": { + "type": "number" + }, + "children_ages": {}, + "currency": { + "type": "select", + "value_type": "string" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "flex_window": { + "type": "select", + "value_type": "number" + }, + "free_cancellation": { + "type": "checkbox" + }, + "hl": { + "type": "select", + "options": [ + "en-us", + "en-gb", + "ar", + "bg", + "ca", + "zh-cn", + "zh-tw", + "hr", + "cs", + "da", + "nl", + "et", + "fi", + "fr", + "de", + "el", + "he", + "hi", + "hu", + "is", + "id", + "it", + "ja", + "ko", + "lv", + "lt", + "ms", + "no", + "pl", + "pt-br", + "pt-pt", + "ro", + "ru", + "sr", + "sk", + "sl", + "es", + "es-ar", + "es-mx", + "sv", + "tl", + "th", + "tr", + "uk", + "vi" + ] + }, + "hotel_class": {}, + "json_restrictor": {}, + "limit": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "nflt": {}, + "no_cache": { + "type": "checkbox" + }, + "offset": { + "type": "number" + }, + "output": {}, + "property_types": {}, + "q": { + "required": true + }, + "rating": { + "type": "select", + "value_type": "number" + }, + "rooms": { + "type": "number" + }, + "session_token": {}, + "sort_by": { + "type": "select", + "options": [ + "popularity", + "upsort_bh", + "price", + "price_from_high_to_low", + "review_score_and_price", + "bayesian_review_score", + "class", + "class_asc", + "class_and_price", + "distance_from_search", + "closest_beach_distance_v2", + "closest_ski_lift_distance" + ] + }, + "zero_trace": {} + }, + "brave": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "options": [ + "all", + "ar", + "au", + "at", + "be", + "br", + "ca", + "cl", + "cn", + "dk", + "fi", + "fr", + "de", + "gr", + "hk", + "in", + "id", + "it", + "jp", + "kr", + "my", + "mx", + "nl", + "nz", + "no", + "pl", + "pt", + "ph", + "ru", + "sa", + "sg", + "za", + "es", + "se", + "ch", + "tw", + "tr", + "gb", + "us" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "az", + "bg", + "br", + "ca", + "cs", + "cy", + "da", + "de", + "el", + "en", + "es", + "et", + "eu", + "fi", + "fr", + "gl", + "hr", + "hu", + "id", + "it", + "ja", + "ka", + "ko", + "lt", + "lv", + "ms", + "nb", + "nl", + "pl", + "pt", + "ro", + "ru", + "sk", + "sl", + "sq", + "sr", + "sv", + "sw", + "th", + "tr", + "uk", + "vi", + "zh" + ] + }, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "offset": { + "type": "number" + }, + "output": {}, + "q": { + "required": true + }, + "safe_search": { + "type": "select", + "options": [ + "off", + "moderate", + "strict" + ] + }, + "spellcheck": { + "type": "checkbox" + }, + "tf": {}, + "zero_trace": {} + }, + "brave_ai_mode": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "options": [ + "ar", + "au", + "at", + "be", + "br", + "ca", + "cl", + "cn", + "dk", + "fi", + "fr", + "de", + "gr", + "hk", + "in", + "id", + "it", + "jp", + "kr", + "my", + "mx", + "nl", + "nz", + "no", + "pl", + "pt", + "ph", + "ru", + "sa", + "sg", + "za", + "es", + "se", + "ch", + "tw", + "tr", + "gb", + "us" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "az", + "bg", + "br", + "ca", + "cs", + "cy", + "da", + "de", + "el", + "en", + "es", + "et", + "eu", + "fi", + "fr", + "gl", + "hr", + "hu", + "id", + "it", + "ja", + "ka", + "ko", + "lt", + "lv", + "ms", + "nb", + "nl", + "pl", + "pt", + "ro", + "ru", + "sk", + "sl", + "sq", + "sr", + "sv", + "sw", + "th", + "tr", + "uk", + "vi", + "zh" + ] + }, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safeSearch": { + "type": "select", + "options": [ + "off", + "moderate", + "strict" + ] + }, + "subsequent_request_token": {}, + "units_of_measurement": { + "type": "select", + "options": [ + "metric", + "us" + ] + }, + "zero_trace": {} + }, + "brave_images": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "options": [ + "ar", + "au", + "at", + "be", + "br", + "ca", + "cl", + "cn", + "dk", + "fi", + "fr", + "de", + "gr", + "hk", + "in", + "id", + "it", + "jp", + "kr", + "my", + "mx", + "nl", + "nz", + "no", + "pl", + "pt", + "ph", + "ru", + "sa", + "sg", + "za", + "es", + "se", + "ch", + "tw", + "tr", + "gb", + "us" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe_search": { + "type": "select", + "options": [ + "off", + "moderate", + "strict" + ] + }, + "spelling": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "brave_videos": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "options": [ + "ar", + "au", + "at", + "be", + "br", + "ca", + "cl", + "cn", + "dk", + "fi", + "fr", + "de", + "gr", + "hk", + "in", + "id", + "it", + "jp", + "kr", + "my", + "mx", + "nl", + "nz", + "no", + "pl", + "pt", + "ph", + "ru", + "sa", + "sg", + "za", + "es", + "se", + "ch", + "tw", + "tr", + "gb", + "us" + ] + }, + "date": { + "type": "select", + "options": [ + "past_day", + "past_week", + "past_month", + "past_year" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "safe_search": { + "type": "select", + "options": [ + "off", + "moderate", + "strict" + ] + }, + "spelling": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "doordash": { + "address": { + "required": true + }, + "api_key": { + "required": true + }, + "async": {}, + "deals": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "fastest": { + "type": "checkbox" + }, + "json_restrictor": {}, + "min_rating": { + "type": "select", + "value_type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "pickup": { + "type": "checkbox" + }, + "q": { + "required": true + }, + "store_type": { + "type": "select", + "options": [ + "all", + "restaurant", + "grocery", + "retail", + "pets", + "alcohol", + "flowers" + ] + }, + "zero_trace": {} + }, + "duck_ai": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "model": { + "type": "select", + "options": [ + "gpt-5.6-luna", + "gpt-6-luna", + "gpt-5.4-mini", + "claude-haiku-4-5", + "mistral-small-2603", + "tinfoil/gpt-oss-120b", + "tinfoil/gemma4-31b" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "subsequent_request_token": {}, + "zero_trace": {} + }, + "duckduckgo": { + "api_key": { + "required": true + }, + "async": {}, + "df": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "kl": { + "type": "select", + "options": [ + "ar-es", + "au-en", + "at-de", + "be-fr", + "be-nl", + "br-pt", + "bg-bg", + "ca-en", + "ca-fr", + "ct-ca", + "cl-es", + "cn-zh", + "co-es", + "hr-hr", + "cz-cs", + "dk-da", + "ee-et", + "fi-fi", + "fr-fr", + "de-de", + "gr-el", + "hk-tzh", + "hu-hu", + "is-is", + "in-en", + "id-en", + "ie-en", + "il-en", + "it-it", + "jp-jp", + "kr-kr", + "lv-lv", + "lt-lt", + "my-en", + "mx-es", + "nl-nl", + "nz-en", + "no-no", + "pk-en", + "pe-es", + "ph-en", + "pl-pl", + "pt-pt", + "ro-ro", + "ru-ru", + "xa-ar", + "sg-en", + "sk-sk", + "sl-sl", + "za-en", + "es-ca", + "es-es", + "se-sv", + "ch-de", + "ch-fr", + "tw-tzh", + "th-en", + "tr-tr", + "us-en", + "us-es", + "ua-uk", + "uk-en", + "vn-en", + "wt-wt" + ] + }, + "m": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "value_type": "number" + }, + "search_assist": { + "type": "checkbox" + }, + "start": { + "type": "number" + }, + "zero_trace": {} + }, + "duckduckgo_light": { + "api_key": { + "required": true + }, + "async": {}, + "df": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "kl": { + "type": "select", + "options": [ + "ar-es", + "au-en", + "at-de", + "be-fr", + "be-nl", + "br-pt", + "bg-bg", + "ca-en", + "ca-fr", + "ct-ca", + "cl-es", + "cn-zh", + "co-es", + "hr-hr", + "cz-cs", + "dk-da", + "ee-et", + "fi-fi", + "fr-fr", + "de-de", + "gr-el", + "hk-tzh", + "hu-hu", + "is-is", + "in-en", + "id-en", + "ie-en", + "il-en", + "it-it", + "jp-jp", + "kr-kr", + "lv-lv", + "lt-lt", + "my-en", + "mx-es", + "nl-nl", + "nz-en", + "no-no", + "pk-en", + "pe-es", + "ph-en", + "pl-pl", + "pt-pt", + "ro-ro", + "ru-ru", + "xa-ar", + "sg-en", + "sk-sk", + "sl-sl", + "za-en", + "es-ca", + "es-es", + "se-sv", + "ch-de", + "ch-fr", + "tw-tzh", + "th-en", + "tr-tr", + "us-en", + "us-es", + "ua-uk", + "uk-en", + "vn-en", + "wt-wt" + ] + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "duckduckgo_maps": { + "api_key": { + "required": true + }, + "async": {}, + "bbox": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "strict_bbox": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "duckduckgo_news": { + "api_key": { + "required": true + }, + "async": {}, + "df": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "kl": { + "type": "select", + "options": [ + "ar-es", + "au-en", + "at-de", + "be-fr", + "be-nl", + "br-pt", + "bg-bg", + "ca-en", + "ca-fr", + "ct-ca", + "cl-es", + "cn-zh", + "co-es", + "hr-hr", + "cz-cs", + "dk-da", + "ee-et", + "fi-fi", + "fr-fr", + "de-de", + "gr-el", + "hk-tzh", + "hu-hu", + "is-is", + "in-en", + "id-en", + "ie-en", + "il-en", + "it-it", + "jp-jp", + "kr-kr", + "lv-lv", + "lt-lt", + "my-en", + "mx-es", + "nl-nl", + "nz-en", + "no-no", + "pk-en", + "pe-es", + "ph-en", + "pl-pl", + "pt-pt", + "ro-ro", + "ru-ru", + "xa-ar", + "sg-en", + "sk-sk", + "sl-sl", + "za-en", + "es-ca", + "es-es", + "se-sv", + "ch-de", + "ch-fr", + "tw-tzh", + "th-en", + "tr-tr", + "us-en", + "us-es", + "ua-uk", + "uk-en", + "vn-en", + "wt-wt" + ] + }, + "m": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "value_type": "number" + }, + "start": { + "type": "number" + }, + "zero_trace": {} + }, + "duckduckgo_shopping": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "filters": {}, + "json_restrictor": {}, + "kl": { + "type": "select", + "options": [ + "ar-es", + "au-en", + "at-de", + "be-fr", + "be-nl", + "br-pt", + "bg-bg", + "ca-en", + "ca-fr", + "cl-es", + "co-es", + "hr-hr", + "cz-cs", + "dk-da", + "ee-et", + "fi-fi", + "fr-fr", + "de-de", + "gr-el", + "hu-hu", + "is-is", + "in-en", + "ie-en", + "it-it", + "jp-jp", + "kr-kr", + "lv-lv", + "lt-lt", + "mx-es", + "nl-nl", + "no-no", + "pe-es", + "pl-pl", + "pt-pt", + "ro-ro", + "sk-sk", + "sl-sl", + "za-en", + "es-es", + "se-sv", + "ch-de", + "ch-fr", + "tr-tr", + "us-en", + "us-es", + "uk-en" + ] + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "ebay": { + "LH_ItemCondition": {}, + "LH_PrefLoc": { + "type": "select", + "value_type": "number" + }, + "_blrs": { + "type": "checkbox" + }, + "_dmd": { + "type": "select", + "value_type": "number" + }, + "_ipg": { + "type": "select", + "value_type": "number" + }, + "_nkw": { + "required": true + }, + "_pgn": { + "type": "number" + }, + "_salic": { + "type": "select", + "value_type": "number" + }, + "_sasl": {}, + "_saslop": { + "type": "select", + "value_type": "number" + }, + "_sop": { + "type": "select", + "value_type": "number" + }, + "_stpos": {}, + "_udhi": { + "type": "number" + }, + "_udlo": { + "type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "buying_format": { + "type": "select", + "options": [ + "Auction", + "BIN", + "BO" + ] + }, + "category_id": {}, + "ebay_domain": { + "type": "select", + "options": [ + "ebay.com.au", + "ebay.at", + "ebay.ca", + "ebay.fr", + "ebay.de", + "ebay.com.hk", + "ebay.ie", + "ebay.it", + "ebay.com.my", + "ebay.nl", + "ebay.pl", + "ebay.com.sg", + "ebay.es", + "ebay.ch", + "ebay.co.uk", + "ebay.com" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "popular_filters": {}, + "show_only": {}, + "zero_trace": {} + }, + "ebay_product": { + "api_key": { + "required": true + }, + "async": {}, + "ebay_domain": { + "type": "select", + "options": [ + "ebay.com.au", + "ebay.at", + "ebay.ca", + "ebay.fr", + "ebay.de", + "ebay.com.hk", + "ebay.ie", + "ebay.it", + "ebay.com.my", + "ebay.nl", + "ebay.pl", + "ebay.com.sg", + "ebay.es", + "ebay.ch", + "ebay.co.uk", + "ebay.com" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lang": { + "type": "select", + "value_type": "string" + }, + "locale": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "shipping_country": { + "type": "select", + "value_type": "string" + }, + "zero_trace": {} + }, + "ebay_seller": { + "LH_ItemCondition": {}, + "_ipg": { + "type": "select", + "value_type": "number" + }, + "_pgn": { + "type": "number" + }, + "_sop": { + "type": "select", + "value_type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "buying_format": { + "type": "select", + "value_type": "number" + }, + "ebay_domain": { + "type": "select", + "options": [ + "ebay.com.au", + "ebay.at", + "ebay.ca", + "ebay.fr", + "ebay.de", + "ebay.com.hk", + "ebay.ie", + "ebay.it", + "ebay.com.my", + "ebay.nl", + "ebay.pl", + "ebay.com.sg", + "ebay.es", + "ebay.ch", + "ebay.co.uk", + "ebay.com" + ] + }, + "engine": { + "required": true + }, + "free_shipping": { + "type": "checkbox" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "seller_id": { + "required": true + }, + "type": { + "type": "select", + "required": true, + "options": [ + "user", + "store" + ] + }, + "zero_trace": {} + }, + "eventbrite": { + "api_key": { + "required": true + }, + "async": {}, + "category": { + "type": "select", + "options": [ + "business_and_professional", + "science_and_technology", + "music", + "film_media_and_entertainment", + "performing_and_visual_arts", + "fashion_and_beauty", + "health_and_wellness", + "sports_and_fitness", + "travel_and_outdoor", + "food_and_drink", + "charity_and_causes", + "government_and_politics", + "community_and_culture", + "religion_and_spirituality", + "family_and_education", + "seasonal_and_holiday", + "home_and_lifestyle", + "auto_boat_and_air", + "hobbies_and_special_interest", + "school_activities", + "other" + ] + }, + "date": { + "type": "select", + "options": [ + "today", + "tomorrow", + "this_weekend", + "this_week", + "next_week", + "this_month", + "next_month" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "event_type": { + "type": "select", + "options": [ + "conference", + "seminar", + "tradeshow", + "convention", + "festival", + "concert", + "screening", + "dinner", + "class", + "meeting", + "party", + "rally", + "tournament", + "game", + "race", + "tour", + "attraction", + "camp", + "appearance", + "other" + ] + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "no_cache": { + "type": "checkbox" + }, + "online": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "price": { + "type": "select", + "options": [ + "free", + "paid" + ] + }, + "q": {}, + "sort_by": { + "type": "select", + "options": [ + "date" + ] + }, + "start_date": {}, + "zero_trace": {} + }, + "extract": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "exclude_tags": {}, + "include_markdown": { + "type": "checkbox" + }, + "include_sitemap": { + "type": "checkbox" + }, + "include_subdomains": { + "type": "checkbox" + }, + "include_tags": {}, + "json_restrictor": {}, + "max_depth": { + "type": "number" + }, + "max_pages": { + "type": "number" + }, + "mode": { + "type": "select", + "options": [ + "scrape", + "map", + "crawl" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "prefetch_delay": { + "type": "number" + }, + "timeout": { + "type": "number" + }, + "url": { + "required": true + }, + "zero_trace": {} + }, + "facebook_marketplace": { + "api_key": { + "required": true + }, + "async": {}, + "availability": { + "type": "select", + "options": [ + "available", + "sold" + ] + }, + "category": { + "type": "select", + "options": [ + "apparel", + "classifieds", + "electronics", + "entertainment", + "family", + "free", + "garden", + "hobbies", + "home", + "home-improvements", + "instruments", + "office-supplies", + "pets", + "propertyrentals", + "sports", + "toys", + "vehicles" + ] + }, + "condition": {}, + "days_since_listed": { + "type": "select", + "value_type": "number" + }, + "delivery_method": { + "type": "select", + "options": [ + "local_pick_up", + "shipping" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "radius": { + "type": "number" + }, + "sort_by": { + "type": "select", + "options": [ + "best_match", + "distance_ascend", + "creation_time_descend", + "price_ascend", + "price_descend" + ] + }, + "zero_trace": {} + }, + "facebook_profile": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "profile_id": { + "required": true + }, + "zero_trace": {} + }, + "flightradar24": { + "aircraft_type": {}, + "airline": {}, + "airport": {}, + "api_key": { + "required": true + }, + "arrival_id": {}, + "async": {}, + "callsign": {}, + "departure_id": {}, + "engine": { + "required": true + }, + "flight_number": {}, + "json_restrictor": {}, + "map_bounds": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "registration": {}, + "zero_trace": {} + }, + "glassdoor_companies": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "location": {}, + "min_rating": { + "type": "select", + "value_type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": {}, + "zero_trace": {} + }, + "glassdoor_jobs": { + "api_key": { + "required": true + }, + "async": {}, + "date_posted": { + "type": "select", + "value_type": "number" + }, + "easy_apply": { + "type": "checkbox" + }, + "employer_id": {}, + "engine": { + "required": true + }, + "job_type": { + "type": "select", + "options": [ + "full_time", + "part_time", + "contract" + ] + }, + "json_restrictor": {}, + "location": {}, + "max_salary": { + "type": "number" + }, + "min_rating": { + "type": "select", + "value_type": "number" + }, + "min_salary": { + "type": "number" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "radius": { + "type": "select", + "value_type": "number" + }, + "remote": { + "type": "checkbox" + }, + "seniority_level": { + "type": "select", + "options": [ + "internship", + "entry_level", + "mid_senior_level", + "director", + "executive" + ] + }, + "zero_trace": {} + }, + "glassdoor_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "current_employees": { + "type": "checkbox" + }, + "employer_id": { + "required": true + }, + "employment_status": {}, + "engine": { + "required": true + }, + "job_title": {}, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "en", + "fr", + "de", + "es", + "pt", + "it", + "nl" + ] + }, + "location": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": {}, + "rating": { + "type": "select", + "value_type": "number" + }, + "sort_by": { + "type": "select", + "options": [ + "most_relevant", + "newest", + "oldest", + "highest_rating", + "lowest_rating" + ] + }, + "zero_trace": {} + }, + "google": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "color_scheme": { + "type": "select", + "options": [ + "light", + "dark" + ] + }, + "cr": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": {}, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "ibp": {}, + "json_restrictor": {}, + "kgmid": {}, + "lat": { + "type": "number" + }, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "lr": {}, + "lsig": {}, + "ludocid": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "radius": { + "type": "number" + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "si": {}, + "start": { + "type": "number" + }, + "tbm": { + "type": "select", + "options": [ + "isch", + "lcl", + "nws", + "shop", + "vid", + "pts", + "bks" + ] + }, + "tbs": {}, + "udm": { + "type": "select", + "value_type": "number" + }, + "uds": {}, + "uule": {}, + "zero_trace": {} + }, + "google_about_this_result": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "ilps": {}, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "req_token": {}, + "zero_trace": {} + }, + "google_ads": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location", + "required": true + }, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "zero_trace": {} + }, + "google_ads_transparency_center": { + "advertiser_id": {}, + "api_key": { + "required": true + }, + "async": {}, + "creative_format": { + "type": "dropdown", + "options": [ + "text", + "image", + "video" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "get_advertiser": { + "type": "checkbox" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "platform": { + "type": "select", + "options": [ + "PLAY", + "MAPS", + "SEARCH", + "SHOPPING", + "YOUTUBE" + ] + }, + "political_ads": { + "type": "checkbox" + }, + "region": { + "type": "dropdown", + "value_type": "number" + }, + "start_date": {}, + "text": {}, + "zero_trace": {} + }, + "google_ads_transparency_center_ad_details": { + "advertiser_id": { + "required": true + }, + "api_key": { + "required": true + }, + "async": {}, + "creative_id": { + "required": true + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "region": { + "type": "dropdown", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_ai_mode": { + "api_key": { + "required": true + }, + "async": {}, + "continuable": { + "type": "checkbox" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "image_url": {}, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "subsequent_request_token": {}, + "uule": {}, + "zero_trace": {} + }, + "google_ai_overview": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page_token": { + "required": true + }, + "zero_trace": {} + }, + "google_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "client": { + "type": "select", + "options": [ + "chrome", + "chrome-omni", + "gws-wiz", + "safari", + "firefox", + "psy-ab", + "toolbar", + "youtube", + "gws-wiz-local" + ] + }, + "cp": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_books": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "document_type": { + "type": "select", + "options": [ + "books", + "magazines", + "newspapers" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "start": { + "type": "number" + }, + "start_date": {}, + "tbs": {}, + "view": { + "type": "select", + "options": [ + "preview", + "full" + ] + }, + "zero_trace": {} + }, + "google_event_details": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "event_token": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "nearby_places": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "search_results": { + "type": "checkbox" + }, + "similar_events": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "google_events": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "uule": {}, + "zero_trace": {} + }, + "google_finance": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "window": { + "type": "dropdown", + "options": [ + "1D", + "5D", + "1M", + "6M", + "YTD", + "1Y", + "5Y", + "MAX" + ] + }, + "zero_trace": {} + }, + "google_finance_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_finance_markets": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "trend": { + "type": "select", + "required": true, + "options": [ + "indexes" + ] + }, + "zero_trace": {} + }, + "google_flights": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "arrival_id": {}, + "async": {}, + "bags": { + "type": "number" + }, + "booking_token": {}, + "children": { + "type": "number" + }, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "deep_search": { + "type": "checkbox" + }, + "departure_id": {}, + "departure_token": {}, + "emissions": { + "type": "select", + "value_type": "number" + }, + "engine": { + "required": true + }, + "exclude_airlines": {}, + "exclude_basic": { + "type": "checkbox" + }, + "exclude_conns": {}, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "include_airlines": {}, + "infants_in_seat": { + "type": "number" + }, + "infants_on_lap": { + "type": "number" + }, + "json_restrictor": {}, + "layover_duration": {}, + "max_duration": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "multi_city_json": {}, + "no_cache": { + "type": "checkbox" + }, + "outbound_date": {}, + "outbound_times": {}, + "output": {}, + "return_date": {}, + "return_times": {}, + "selected_flights_json": {}, + "show_hidden": { + "type": "checkbox" + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "stops": { + "type": "select", + "value_type": "number" + }, + "travel_class": { + "type": "select", + "value_type": "number" + }, + "type": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_flights_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "exclude_regions": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_flights_calendar": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "arrival_id": { + "required": true + }, + "async": {}, + "children": { + "type": "number" + }, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "date_range_end": {}, + "date_range_start": {}, + "departure_id": { + "required": true + }, + "engine": { + "required": true + }, + "fixed_outbound_date": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "infants_in_seat": { + "type": "number" + }, + "infants_on_lap": { + "type": "number" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "round_trip_days": { + "type": "number" + }, + "travel_class": { + "type": "select", + "value_type": "number" + }, + "type": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_flights_deals": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "children": { + "type": "number" + }, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "departure_id": {}, + "engine": { + "required": true + }, + "exclude_airlines": {}, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "include_airlines": {}, + "infants_in_seat": { + "type": "number" + }, + "infants_on_lap": { + "type": "number" + }, + "json_restrictor": {}, + "max_duration": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "outbound_date": {}, + "output": {}, + "query": {}, + "return_date": {}, + "stops": { + "type": "select", + "value_type": "number" + }, + "travel_class": { + "type": "select", + "value_type": "number" + }, + "travel_duration": { + "type": "select", + "value_type": "number" + }, + "trip_length": {}, + "type": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_forums": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "period_unit": { + "type": "select", + "options": [ + "s", + "n", + "h", + "d", + "w", + "m", + "y" + ] + }, + "period_value": { + "type": "number" + }, + "q": { + "required": true + }, + "start": { + "type": "number" + }, + "start_date": {}, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_gemini": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "subsequent_request_token": {}, + "zero_trace": {} + }, + "google_hotels": { + "adults": { + "type": "number" + }, + "amenities": {}, + "api_key": { + "required": true + }, + "async": {}, + "bathrooms": { + "type": "number" + }, + "bedrooms": { + "type": "number" + }, + "brands": {}, + "check_in_date": { + "required": true + }, + "check_out_date": { + "required": true + }, + "children": { + "type": "number" + }, + "children_ages": {}, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "eco_certified": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "free_cancellation": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "hotel_class": {}, + "json_restrictor": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "property_token": {}, + "property_types": {}, + "q": { + "required": true + }, + "rating": { + "type": "select", + "value_type": "number" + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "special_offers": { + "type": "checkbox" + }, + "vacation_rentals": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "google_hotels_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_hotels_photos": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "property_token": { + "required": true + }, + "zero_trace": {} + }, + "google_hotels_price_calendar": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "children": { + "type": "number" + }, + "children_ages": {}, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "end_date": { + "required": true + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "property_token": { + "required": true + }, + "start_date": { + "required": true + }, + "zero_trace": {} + }, + "google_hotels_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "category_token": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "property_token": { + "required": true + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "source_number": { + "type": "number" + }, + "zero_trace": {} + }, + "google_images": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "chips": {}, + "cr": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "ijn": { + "type": "number" + }, + "image_color": { + "type": "select", + "options": [ + "bw", + "trans", + "red", + "orange", + "yellow", + "green", + "teal", + "blue", + "purple", + "pink", + "white", + "gray", + "black", + "brown" + ] + }, + "image_type": { + "type": "select", + "options": [ + "face", + "photo", + "clipart", + "lineart", + "animated" + ] + }, + "imgar": { + "type": "select", + "options": [ + "s", + "t", + "w", + "xw" + ] + }, + "imgsz": { + "type": "select", + "options": [ + "l", + "m", + "i", + "qsvga", + "vga", + "svga", + "xga", + "2mp", + "4mp", + "6mp", + "8mp", + "10mp", + "12mp", + "15mp", + "20mp", + "40mp", + "70mp" + ] + }, + "json_restrictor": {}, + "licenses": { + "type": "select", + "options": [ + "f", + "fc", + "fm", + "fmc", + "cl", + "ol" + ] + }, + "location": { + "type": "location" + }, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "period_unit": { + "type": "select", + "options": [ + "s", + "n", + "h", + "d", + "w", + "m", + "y" + ] + }, + "period_value": { + "type": "number" + }, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start_date": {}, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_images_light": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "cr": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "end_date": {}, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "image_color": { + "type": "select", + "options": [ + "bw", + "trans", + "red", + "orange", + "yellow", + "green", + "teal", + "blue", + "purple", + "pink", + "white", + "gray", + "black", + "brown" + ] + }, + "image_type": { + "type": "select", + "options": [ + "face", + "photo", + "clipart", + "lineart", + "animated" + ] + }, + "imgar": { + "type": "select", + "options": [ + "s", + "t", + "w", + "xw" + ] + }, + "imgsz": { + "type": "select", + "options": [ + "l", + "m", + "i", + "qsvga", + "vga", + "svga", + "xga", + "2mp", + "4mp", + "6mp", + "8mp", + "10mp", + "12mp", + "15mp", + "20mp", + "40mp", + "70mp" + ] + }, + "json_restrictor": {}, + "licenses": { + "type": "select", + "options": [ + "f", + "fc", + "fm", + "fmc", + "cl", + "ol" + ] + }, + "location": { + "type": "location" + }, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "period_unit": { + "type": "select", + "options": [ + "s", + "n", + "h", + "d", + "w", + "m", + "y" + ] + }, + "period_value": { + "type": "number" + }, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "start_date": {}, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_images_related_content": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "related_content_id": { + "required": true + }, + "zero_trace": {} + }, + "google_immersive_product": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "more_stores": { + "type": "checkbox" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page_token": { + "required": true + }, + "zero_trace": {} + }, + "google_jobs": { + "api_key": { + "required": true + }, + "async": {}, + "chips": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lrad": { + "type": "number" + }, + "ltype": { + "type": "checkbox" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "uds": {}, + "uule": {}, + "zero_trace": {} + }, + "google_jobs_listing": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_lens": { + "api_key": { + "required": true + }, + "async": {}, + "auto_crop": { + "type": "checkbox" + }, + "country": { + "type": "select", + "value_type": "string" + }, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "image_id": { + "type": "image" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "type": { + "type": "select", + "required": true, + "options": [ + "all", + "exact_matches", + "visual_matches" + ] + }, + "url": { + "required": true + }, + "zero_trace": {} + }, + "google_light": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "uule": {}, + "zero_trace": {} + }, + "google_local": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "ludocid": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "start": { + "type": "number" + }, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_local_services": { + "api_key": { + "required": true + }, + "async": {}, + "bid": { + "type": "number" + }, + "cid": { + "type": "number" + }, + "data_cid": { + "type": "number", + "required": true + }, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "job_type": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "pid": { + "type": "number" + }, + "q": { + "type": "select", + "required": true, + "value_type": "string" + }, + "zero_trace": {} + }, + "google_maps": { + "api_key": { + "required": true + }, + "async": {}, + "data": {}, + "data_cid": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "ll": {}, + "location": { + "type": "location" + }, + "lon": { + "type": "number" + }, + "m": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "min_rating": { + "type": "select", + "value_type": "number" + }, + "nearby": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "open_at_hour": { + "type": "select", + "value_type": "number" + }, + "open_on_day": { + "type": "select", + "options": [ + "mon", + "tue", + "wed", + "thu", + "fri", + "sat", + "sun" + ] + }, + "open_state": { + "type": "select", + "options": [ + "now", + "24h" + ] + }, + "output": {}, + "place_id": {}, + "q": {}, + "start": { + "type": "number" + }, + "type": { + "type": "select", + "required": true, + "options": [ + "search", + "place" + ] + }, + "z": { + "type": "number" + }, + "zero_trace": {} + }, + "google_maps_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "cp": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "ll": { + "required": true + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_maps_contributor_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "contributor_id": { + "required": true + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "zero_trace": {} + }, + "google_maps_directions": { + "api_key": { + "required": true + }, + "async": {}, + "avoid": {}, + "distance_unit": { + "type": "select", + "value_type": "number" + }, + "end_addr": {}, + "end_coords": {}, + "end_data_id": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "prefer": {}, + "route": { + "type": "select", + "value_type": "number" + }, + "start_addr": {}, + "start_coords": {}, + "start_data_id": {}, + "time": {}, + "travel_mode": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_maps_photo_meta": { + "api_key": { + "required": true + }, + "async": {}, + "data_id": { + "required": true + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_maps_photos": { + "api_key": { + "required": true + }, + "async": {}, + "category_id": {}, + "data_id": { + "required": true + }, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_maps_posts": { + "api_key": { + "required": true + }, + "async": {}, + "data_id": { + "required": true + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_maps_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "data_id": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "num": {}, + "output": {}, + "place_id": {}, + "query": {}, + "sort_by": { + "type": "select", + "options": [ + "qualityScore", + "newestFirst", + "ratingHigh", + "ratingLow" + ] + }, + "topic_id": {}, + "zero_trace": {} + }, + "google_news": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "kgmid": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "publication_token": {}, + "q": {}, + "section_token": {}, + "so": { + "type": "select", + "value_type": "number" + }, + "story_token": {}, + "topic_token": {}, + "zero_trace": {} + }, + "google_news_light": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "uule": {}, + "zero_trace": {} + }, + "google_patents": { + "after": {}, + "api_key": { + "required": true + }, + "assignee": {}, + "async": {}, + "before": {}, + "clustered": { + "type": "select", + "options": [ + "true" + ] + }, + "country": {}, + "dups": { + "type": "select", + "options": [ + "language" + ] + }, + "engine": { + "required": true + }, + "inventor": {}, + "json_restrictor": {}, + "language": {}, + "litigation": { + "type": "select", + "options": [ + "YES", + "NO" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "page": { + "type": "number" + }, + "patents": { + "type": "checkbox" + }, + "q": {}, + "scholar": { + "type": "checkbox" + }, + "sort": { + "type": "select", + "options": [ + "new", + "old" + ] + }, + "status": { + "type": "select", + "options": [ + "GRANT", + "APPLICATION" + ] + }, + "type": { + "type": "select", + "options": [ + "PATENT", + "DESIGN" + ] + }, + "zero_trace": {} + }, + "google_patents_details": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "patent_id": { + "required": true + }, + "zero_trace": {} + }, + "google_play": { + "age": { + "type": "select", + "options": [ + "AGE_RANGE1", + "AGE_RANGE2", + "AGE_RANGE3" + ] + }, + "api_key": { + "required": true + }, + "apps_category": { + "type": "select", + "options": [ + "ART_AND_DESIGN", + "AUTO_AND_VEHICLES", + "BEAUTY", + "BOOKS_AND_REFERENCE", + "BUSINESS", + "COMICS", + "COMMUNICATION", + "DATING", + "EDUCATION", + "ENTERTAINMENT", + "EVENTS", + "FINANCE", + "FOOD_AND_DRINK", + "HEALTH_AND_FITNESS", + "HOUSE_AND_HOME", + "LIBRARIES_AND_DEMO", + "LIFESTYLE", + "MAPS_AND_NAVIGATION", + "MEDICAL", + "MUSIC_AND_AUDIO", + "NEWS_AND_MAGAZINES", + "PARENTING", + "PERSONALIZATION", + "PHOTOGRAPHY", + "PRODUCTIVITY", + "SHOPPING", + "SOCIAL", + "SPORTS", + "TOOLS", + "TRAVEL_AND_LOCAL", + "VIDEO_PLAYERS", + "ANDROID_WEAR", + "WATCH_FACE", + "WEATHER", + "FAMILY" + ] + }, + "async": {}, + "chart": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "section_page_token": {}, + "see_more_token": {}, + "store_device": { + "type": "select", + "options": [ + "phone", + "tablet", + "tv", + "chromebook", + "watch", + "car" + ] + }, + "zero_trace": {} + }, + "google_play_books": { + "age": { + "type": "select", + "options": [ + "AGE_RANGE1", + "AGE_RANGE2", + "AGE_RANGE3" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "books_category": { + "type": "select", + "value_type": "string" + }, + "chart": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "price": { + "type": "select", + "value_type": "number" + }, + "q": {}, + "section_page_token": {}, + "see_more_token": {}, + "zero_trace": {} + }, + "google_play_games": { + "api_key": { + "required": true + }, + "async": {}, + "chart": {}, + "engine": { + "required": true + }, + "games_category": { + "type": "select", + "options": [ + "GAME", + "GAME_ACTION", + "GAME_ADVENTURE", + "GAME_ARCADE", + "GAME_BOARD", + "GAME_CARD", + "GAME_CASINO", + "GAME_CASUAL", + "GAME_EDUCATIONAL", + "GAME_MUSIC", + "GAME_PUZZLE", + "GAME_RACING", + "GAME_ROLE_PLAYING", + "GAME_SIMULATION", + "GAME_SPORTS", + "GAME_STRATEGY", + "GAME_TRIVIA", + "GAME_WORD" + ] + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "section_page_token": {}, + "see_more_token": {}, + "store_device": { + "type": "select", + "options": [ + "phone", + "windows", + "tablet", + "tv", + "chromebook", + "watch" + ] + }, + "zero_trace": {} + }, + "google_play_movies": { + "age": { + "type": "select", + "options": [ + "AGE_RANGE1", + "AGE_RANGE2", + "AGE_RANGE3" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "chart": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "movies_category": { + "type": "select", + "value_type": "number" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "section_page_token": {}, + "see_more_token": {}, + "zero_trace": {} + }, + "google_play_product": { + "all_reviews": { + "type": "checkbox" + }, + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "platform": { + "type": "select", + "options": [ + "phone", + "tablet", + "watch", + "chromebook", + "tv", + "car" + ] + }, + "product_id": { + "required": true + }, + "rating": { + "type": "select", + "value_type": "number" + }, + "season_id": {}, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "store": { + "type": "select", + "required": true, + "options": [ + "apps", + "movies", + "tv", + "books", + "audiobooks" + ] + }, + "zero_trace": {} + }, + "google_product": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "options": [ + "ai", + "ar", + "aw", + "au", + "at", + "be", + "bm", + "br", + "io", + "ca", + "ky", + "cl", + "cx", + "cc", + "co", + "cz", + "dk", + "fk", + "fi", + "fr", + "gf", + "pf", + "tf", + "de", + "gr", + "gp", + "hm", + "hk", + "hu", + "in", + "id", + "ie", + "il", + "it", + "jp", + "kr", + "my", + "mq", + "yt", + "mx", + "ms", + "nl", + "nc", + "nz", + "nf", + "no", + "ph", + "pl", + "pt", + "re", + "ro", + "ru", + "pm", + "sa", + "sg", + "sk", + "za", + "gs", + "es", + "se", + "ch", + "tw", + "th", + "tk", + "tr", + "tc", + "ua", + "ae", + "uk", + "gb", + "us", + "vn", + "vg", + "wf" + ] + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "offer_view": { + "type": "checkbox" + }, + "output": {}, + "page_token": {}, + "product_id": {}, + "zero_trace": {} + }, + "google_related_questions": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "next_page_token": { + "required": true + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_reverse_image": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "image_url": { + "required": true + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": {}, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_scholar": { + "api_key": { + "required": true + }, + "as_rr": { + "type": "checkbox" + }, + "as_sdt": {}, + "as_vis": { + "type": "checkbox" + }, + "as_yhi": { + "type": "number" + }, + "as_ylo": { + "type": "number" + }, + "async": {}, + "cites": {}, + "cluster": {}, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "lr": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "scisbd": { + "type": "select", + "value_type": "number" + }, + "start": { + "type": "number" + }, + "zero_trace": {} + }, + "google_scholar_author": { + "api_key": { + "required": true + }, + "async": {}, + "author_id": { + "required": true + }, + "citation_id": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "sort": { + "type": "select", + "options": [ + "title", + "pubdate" + ] + }, + "start": { + "type": "number" + }, + "view_op": { + "type": "select", + "options": [ + "view_citation", + "list_colleagues" + ] + }, + "zero_trace": {} + }, + "google_scholar_case_law": { + "api_key": { + "required": true + }, + "async": {}, + "case_id": { + "required": true + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_scholar_cite": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_shopping": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "free_shipping": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "options": [ + "ai", + "ar", + "aw", + "au", + "at", + "be", + "bm", + "br", + "io", + "ca", + "ky", + "cl", + "cx", + "cc", + "co", + "cz", + "dk", + "fk", + "fi", + "fr", + "gf", + "pf", + "tf", + "de", + "gr", + "gp", + "hm", + "hk", + "hu", + "in", + "id", + "ie", + "il", + "it", + "jp", + "kr", + "my", + "mq", + "yt", + "mx", + "ms", + "nl", + "nc", + "nz", + "nf", + "no", + "ph", + "pl", + "pt", + "re", + "ro", + "ru", + "pm", + "sa", + "sg", + "sk", + "za", + "gs", + "es", + "se", + "ch", + "tw", + "th", + "tk", + "tr", + "tc", + "ua", + "ae", + "uk", + "gb", + "us", + "vn", + "vg", + "wf" + ] + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "on_sale": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "shoprs": {}, + "small_business": { + "type": "checkbox" + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "start": { + "type": "number" + }, + "uule": {}, + "zero_trace": {} + }, + "google_shopping_filters": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "options": [ + "ai", + "ar", + "aw", + "au", + "at", + "be", + "bm", + "br", + "io", + "ca", + "ky", + "cl", + "cx", + "cc", + "co", + "cz", + "dk", + "fk", + "fi", + "fr", + "gf", + "pf", + "tf", + "de", + "gr", + "gp", + "hm", + "hk", + "hu", + "in", + "id", + "ie", + "il", + "it", + "jp", + "kr", + "my", + "mq", + "yt", + "mx", + "ms", + "nl", + "nc", + "nz", + "nf", + "no", + "ph", + "pl", + "pt", + "re", + "ro", + "ru", + "pm", + "sa", + "sg", + "sk", + "za", + "gs", + "es", + "se", + "ch", + "tw", + "th", + "tk", + "tr", + "tc", + "ua", + "ae", + "uk", + "gb", + "us", + "vn", + "vg", + "wf" + ] + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "shoprs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_shopping_light": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "free_shipping": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "options": [ + "ai", + "ar", + "aw", + "au", + "at", + "be", + "bm", + "br", + "io", + "ca", + "ky", + "cl", + "cx", + "cc", + "co", + "cz", + "dk", + "fk", + "fi", + "fr", + "gf", + "pf", + "tf", + "de", + "gr", + "gp", + "hm", + "hk", + "hu", + "in", + "id", + "ie", + "il", + "it", + "jp", + "kr", + "my", + "mq", + "yt", + "mx", + "ms", + "nl", + "nc", + "nz", + "nf", + "no", + "ph", + "pl", + "pt", + "re", + "ro", + "ru", + "pm", + "sa", + "sg", + "sk", + "za", + "gs", + "es", + "se", + "ch", + "tw", + "th", + "tk", + "tr", + "tc", + "ua", + "ae", + "uk", + "gb", + "us", + "vn", + "vg", + "wf" + ] + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "on_sale": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "shoprs": {}, + "small_business": { + "type": "checkbox" + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "start": { + "type": "number" + }, + "uule": {}, + "zero_trace": {} + }, + "google_short_videos": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_sports": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "kgmid": { + "required": true + }, + "moa": {}, + "mob": {}, + "mpd": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "season_kgmid": {}, + "sp": { + "type": "select", + "required": true, + "options": [ + "ft", + "bs", + "bb", + "cr", + "af", + "ih", + "rg" + ] + }, + "tab": { + "type": "select", + "options": [ + "gm", + "sn", + "pl", + "br", + "st", + "rn", + "ov" + ] + }, + "type": { + "type": "select", + "required": true, + "options": [ + "game", + "league", + "team" + ] + }, + "zero_trace": {} + }, + "google_translate": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "from": { + "type": "select", + "required": true, + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "text": { + "required": true + }, + "to": { + "type": "select", + "required": true, + "value_type": "string" + }, + "zero_trace": {} + }, + "google_travel_explore": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "arrival_area_id": {}, + "arrival_id": {}, + "async": {}, + "bags": { + "type": "number" + }, + "children": { + "type": "number" + }, + "currency": { + "type": "select", + "options": [ + "ALL", + "DZD", + "ARS", + "AMD", + "AWG", + "AUD", + "AZN", + "BSD", + "BHD", + "BYN", + "BMD", + "BAM", + "BRL", + "GBP", + "BGN", + "XPF", + "CAD", + "CLP", + "CNY", + "COP", + "CRC", + "CUP", + "CZK", + "DKK", + "DOP", + "EGP", + "EUR", + "GEL", + "HKD", + "HUF", + "ISK", + "INR", + "IDR", + "IRR", + "ILS", + "JMD", + "JPY", + "JOD", + "KZT", + "KWD", + "LBP", + "MKD", + "MYR", + "MXN", + "MDL", + "MAD", + "TWD", + "NZD", + "NOK", + "OMR", + "PKR", + "PAB", + "PEN", + "PHP", + "PLN", + "QAR", + "RON", + "RUB", + "SAR", + "RSD", + "SGD", + "ZAR", + "KRW", + "SEK", + "CHF", + "THB", + "TRY", + "USD", + "UAH", + "AED", + "VND" + ] + }, + "departure_id": { + "required": true + }, + "engine": { + "required": true + }, + "exclude_airlines": {}, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "include_airlines": {}, + "infants_in_seat": { + "type": "number" + }, + "infants_on_lap": { + "type": "number" + }, + "interest": { + "type": "select", + "value_type": "number" + }, + "json_restrictor": {}, + "max_duration": { + "type": "number" + }, + "max_price": { + "type": "number" + }, + "month": {}, + "no_cache": { + "type": "checkbox" + }, + "outbound_date": {}, + "output": {}, + "return_date": {}, + "stops": { + "type": "select", + "value_type": "number" + }, + "travel_class": { + "type": "select", + "value_type": "number" + }, + "travel_duration": { + "type": "select", + "value_type": "number" + }, + "travel_mode": { + "type": "select", + "value_type": "number" + }, + "type": { + "type": "select", + "value_type": "number" + }, + "zero_trace": {} + }, + "google_trends": { + "api_key": { + "required": true + }, + "async": {}, + "cat": { + "type": "select", + "value_type": "number" + }, + "csv": { + "type": "checkbox" + }, + "data_type": { + "type": "select", + "options": [ + "TIMESERIES", + "GEO_MAP", + "GEO_MAP_0", + "RELATED_TOPICS", + "RELATED_QUERIES" + ] + }, + "date": {}, + "engine": { + "required": true + }, + "geo": {}, + "gprop": { + "type": "select", + "options": [ + "", + "images", + "news", + "froogle", + "youtube" + ] + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "include_low_search_volume": { + "type": "checkbox" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "region": { + "type": "select", + "options": [ + "COUNTRY", + "REGION", + "DMA", + "CITY" + ] + }, + "tz": { + "type": "number" + }, + "zero_trace": {} + }, + "google_trends_autocomplete": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "zero_trace": {} + }, + "google_trends_news": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page_token": { + "required": true + }, + "zero_trace": {} + }, + "google_trends_trending_now": { + "api_key": { + "required": true + }, + "async": {}, + "cat": { + "type": "select", + "options": [ + "all", + "b", + "e", + "m", + "t", + "s", + "h" + ] + }, + "category_id": { + "type": "select", + "value_type": "number" + }, + "date": {}, + "engine": { + "required": true + }, + "frequency": { + "type": "select", + "required": true, + "options": [ + "daily", + "realtime" + ] + }, + "geo": { + "type": "select", + "required": true, + "value_type": "number" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "hours": { + "type": "number" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "only_active": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "google_videos": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "google_videos_light": { + "api_key": { + "required": true + }, + "as_dt": {}, + "as_epq": {}, + "as_eq": {}, + "as_lq": {}, + "as_nhi": {}, + "as_nlo": {}, + "as_oq": {}, + "as_q": {}, + "as_qdr": {}, + "as_rq": {}, + "as_sitesearch": {}, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "filter": { + "type": "checkbox" + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "google_domain": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "location": { + "type": "location" + }, + "lr": {}, + "nfpr": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "tbs": {}, + "uule": {}, + "zero_trace": {} + }, + "home_depot": { + "api_key": { + "required": true + }, + "async": {}, + "country": { + "type": "select", + "options": [ + "us", + "ca" + ] + }, + "delivery_zip": {}, + "engine": { + "required": true + }, + "filter": {}, + "hd_filter_tokens": {}, + "hd_sort": { + "type": "select", + "options": [ + "top_sellers", + "price_low_to_high", + "price_high_to_low", + "top_rated", + "best_match" + ] + }, + "json_restrictor": {}, + "lowerbound": { + "type": "number" + }, + "minmax": {}, + "nao": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "pagesize": {}, + "ps": { + "type": "number" + }, + "q": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "price-asc", + "price-desc", + "reviewAvgRating", + "relevance" + ] + }, + "store": {}, + "store_id": {}, + "upperbound": { + "type": "number" + }, + "zero_trace": {} + }, + "home_depot_product": { + "api_key": { + "required": true + }, + "async": {}, + "delivery_zip": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": {}, + "store_id": {}, + "store_sku": {}, + "zero_trace": {} + }, + "home_depot_product_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "pagesize": {}, + "product_id": { + "required": true + }, + "rating": {}, + "sort_by": { + "type": "select", + "options": [ + "photoreview", + "mosthelpfull", + "oldest", + "newest", + "highestrating", + "lowestrating" + ] + }, + "start": {}, + "term": {}, + "verified_purchases": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "indeed_jobs": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "fromage": { + "type": "select", + "value_type": "number" + }, + "json_restrictor": {}, + "jt": { + "type": "select", + "options": [ + "fulltime", + "parttime", + "contract", + "temporary", + "internship" + ] + }, + "l": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "radius": { + "type": "select", + "value_type": "number" + }, + "sort": { + "type": "select", + "options": [ + "date" + ] + }, + "zero_trace": {} + }, + "instagram_popular": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "keyword": { + "required": true + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "instagram_profile": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "profile_id": { + "required": true + }, + "zero_trace": {} + }, + "meta_ad_library": { + "active_status": { + "type": "select", + "options": [ + "active", + "inactive", + "all" + ] + }, + "ad_type": { + "type": "select", + "options": [ + "all", + "political_and_issue_ads", + "housing_ads", + "employment_ads", + "financial_products_and_services_ads" + ] + }, + "api_key": { + "required": true + }, + "async": {}, + "content_languages": {}, + "country": { + "type": "select", + "value_type": "string" + }, + "end_date": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "media_type": { + "type": "select", + "options": [ + "all", + "image", + "meme", + "image_and_meme", + "video", + "none" + ] + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page_id": {}, + "publisher_platforms": {}, + "q": {}, + "search_type": { + "type": "select", + "options": [ + "keyword_unordered", + "keyword_exact_phrase" + ] + }, + "sort_by": { + "type": "select", + "options": [ + "most_recent", + "impressions_high_to_low", + "impressions_low_to_high" + ] + }, + "start_date": {}, + "zero_trace": {} + }, + "napa": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "relevance", + "price_low_to_high", + "price_high_to_low", + "product_description", + "line_abbreviation", + "part_number" + ] + }, + "store_id": {}, + "zero_trace": {} + }, + "naver": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "page": {}, + "period": {}, + "query": { + "required": true + }, + "sort_by": { + "type": "select", + "value_type": "number" + }, + "start": {}, + "where": { + "type": "select", + "options": [ + "nexearch", + "web", + "news", + "video", + "image" + ] + }, + "zero_trace": {} + }, + "naver_ai_mode": { + "api_key": { + "required": true + }, + "async": {}, + "continuable": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "query": { + "required": true + }, + "subsequent_request_token": {}, + "zero_trace": {} + }, + "naver_ai_overview": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page_token": {}, + "query": {}, + "zero_trace": {} + }, + "naver_maps": { + "adults": { + "type": "number" + }, + "api_key": { + "required": true + }, + "async": {}, + "bookable": { + "type": "checkbox" + }, + "center": {}, + "check_in_date": {}, + "check_out_date": {}, + "children": { + "type": "number" + }, + "coupon": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "naver_pay": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "open_state": { + "type": "select", + "options": [ + "now" + ] + }, + "output": {}, + "page": { + "type": "number" + }, + "query": { + "required": true + }, + "sort_by": { + "type": "select", + "options": [ + "distance" + ] + }, + "wheelchair_accessible": { + "type": "checkbox" + }, + "zero_trace": {} + }, + "open_table_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "open_table_domain": { + "type": "select", + "options": [ + "opentable.com", + "opentable.jp", + "opentable.de", + "opentable.es", + "opentable.ca", + "opentable.hk", + "opentable.ie", + "opentable.sg", + "opentable.nl", + "opentable.com.mx", + "opentable.co.uk", + "opentable.com.au", + "opentable.ae", + "opentable.co.th", + "opentable.it", + "opentable.com.tw", + "opentable.fr" + ] + }, + "output": {}, + "page": { + "type": "number" + }, + "rid": { + "required": true + }, + "zero_trace": {} + }, + "pinterest": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "less_ai": { + "type": "checkbox" + }, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "q": { + "required": true + }, + "type": { + "type": "select", + "options": [ + "pins", + "videos", + "boards", + "profiles", + "products" + ] + }, + "zero_trace": {} + }, + "search_index": { + "api_key": { + "required": true + }, + "as_yhi": {}, + "as_ylo": {}, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "ll": {}, + "mode": { + "type": "select", + "options": [ + "deep" + ] + }, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "product_source": { + "type": "select", + "options": [ + "google", + "amazon", + "walmart", + "ebay", + "home_depot" + ] + }, + "q": { + "required": true + }, + "radius": { + "type": "number" + }, + "safe": { + "type": "select", + "options": [ + "active", + "off" + ] + }, + "start": { + "type": "number" + }, + "type": { + "type": "select", + "options": [ + "web", + "place", + "product", + "video", + "publication" + ] + }, + "zero_trace": {} + }, + "target": { + "api_key": { + "required": true + }, + "async": {}, + "category_id": {}, + "delivery_zip": {}, + "engine": { + "required": true + }, + "facet": {}, + "include_filters": { + "type": "checkbox" + }, + "json_restrictor": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "sort": { + "type": "select", + "options": [ + "relevance", + "featured", + "price_low", + "price_high", + "rating_high", + "best_seller", + "newest" + ] + }, + "spelling": { + "type": "checkbox" + }, + "store_id": {}, + "zero_trace": {} + }, + "tiktok_discover": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "num": { + "type": "number" + }, + "output": {}, + "q": { + "required": true + }, + "session_token": {}, + "start": { + "type": "number" + }, + "zero_trace": {} + }, + "tiktok_shop": { + "api_key": { + "required": true + }, + "async": {}, + "category_id": {}, + "color_id": {}, + "deals": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "rating": { + "type": "select", + "value_type": "number" + }, + "sort": { + "type": "select", + "options": [ + "relevance", + "best_seller", + "newest" + ] + }, + "zero_trace": {} + }, + "trader_joes": { + "api_key": { + "required": true + }, + "async": {}, + "category_id": { + "type": "number" + }, + "characteristics": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "new_products": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "q": { + "required": true + }, + "sort_by": { + "type": "select", + "options": [ + "price_low_to_high", + "price_high_to_low", + "popularity" + ] + }, + "store_id": { + "type": "number" + }, + "tags": {}, + "zero_trace": {} + }, + "trader_joes_product": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "store_id": {}, + "zero_trace": {} + }, + "tripadvisor": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "lat": { + "type": "number" + }, + "limit": { + "type": "number" + }, + "lon": { + "type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "offset": { + "type": "number" + }, + "output": {}, + "q": { + "required": true + }, + "ssrc": { + "type": "select", + "options": [ + "a", + "r", + "A", + "h", + "g", + "v", + "f" + ] + }, + "tripadvisor_domain": { + "type": "select", + "options": [ + "www.tripadvisor.com", + "ar.tripadvisor.com", + "www.tripadvisor.com.ar", + "www.tripadvisor.com.au", + "www.tripadvisor.at", + "www.tripadvisor.be", + "fr.tripadvisor.be", + "www.tripadvisor.com.br", + "www.tripadvisor.ca", + "fr.tripadvisor.ca", + "www.tripadvisor.cl", + "cn.tripadvisor.com", + "www.tripadvisor.co", + "www.tripadvisor.com.pe", + "www.tripadvisor.dk", + "www.tripadvisor.com.eg", + "www.tripadvisor.fr", + "www.tripadvisor.de", + "www.tripadvisor.com.gr", + "www.tripadvisor.com.hk", + "en.tripadvisor.com.hk", + "www.tripadvisor.in", + "www.tripadvisor.co.id", + "www.tripadvisor.ie", + "www.tripadvisor.co.il", + "www.tripadvisor.it", + "www.tripadvisor.jp", + "www.tripadvisor.co.kr", + "www.tripadvisor.com.my", + "www.tripadvisor.com.mx", + "www.tripadvisor.nl", + "www.tripadvisor.co.nz", + "no.tripadvisor.com", + "www.tripadvisor.com.ph", + "www.tripadvisor.pt", + "www.tripadvisor.ru", + "www.tripadvisor.com.sg", + "www.tripadvisor.co.za", + "www.tripadvisor.es", + "www.tripadvisor.se", + "fr.tripadvisor.ch", + "www.tripadvisor.ch", + "it.tripadvisor.ch", + "www.tripadvisor.com.tw", + "th.tripadvisor.com", + "www.tripadvisor.com.tr", + "www.tripadvisor.co.uk", + "www.tripadvisor.com.ve", + "www.tripadvisor.com.vn" + ] + }, + "zero_trace": {} + }, + "tripadvisor_place": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "place_id": { + "required": true + }, + "tripadvisor_domain": { + "type": "select", + "options": [ + "www.tripadvisor.com", + "ar.tripadvisor.com", + "www.tripadvisor.com.ar", + "www.tripadvisor.com.au", + "www.tripadvisor.at", + "www.tripadvisor.be", + "fr.tripadvisor.be", + "www.tripadvisor.com.br", + "www.tripadvisor.ca", + "fr.tripadvisor.ca", + "www.tripadvisor.cl", + "cn.tripadvisor.com", + "www.tripadvisor.co", + "www.tripadvisor.com.pe", + "www.tripadvisor.dk", + "www.tripadvisor.com.eg", + "www.tripadvisor.fr", + "www.tripadvisor.de", + "www.tripadvisor.com.gr", + "www.tripadvisor.com.hk", + "en.tripadvisor.com.hk", + "www.tripadvisor.in", + "www.tripadvisor.co.id", + "www.tripadvisor.ie", + "www.tripadvisor.co.il", + "www.tripadvisor.it", + "www.tripadvisor.jp", + "www.tripadvisor.co.kr", + "www.tripadvisor.com.my", + "www.tripadvisor.com.mx", + "www.tripadvisor.nl", + "www.tripadvisor.co.nz", + "no.tripadvisor.com", + "www.tripadvisor.com.ph", + "www.tripadvisor.pt", + "www.tripadvisor.ru", + "www.tripadvisor.com.sg", + "www.tripadvisor.co.za", + "www.tripadvisor.es", + "www.tripadvisor.se", + "fr.tripadvisor.ch", + "www.tripadvisor.ch", + "it.tripadvisor.ch", + "www.tripadvisor.com.tw", + "th.tripadvisor.com", + "www.tripadvisor.com.tr", + "www.tripadvisor.co.uk", + "www.tripadvisor.com.ve", + "www.tripadvisor.com.vn" + ] + }, + "zero_trace": {} + }, + "tripadvisor_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "language": { + "type": "select", + "options": [ + "ar", + "cs", + "da", + "de", + "el", + "en", + "es", + "fi", + "fr", + "he", + "hu", + "id", + "it", + "ja", + "ko", + "nb", + "nl", + "pl", + "pt", + "ru", + "sk", + "sr", + "sv", + "th", + "tr", + "vi", + "zh" + ] + }, + "limit": {}, + "month": {}, + "no_cache": { + "type": "checkbox" + }, + "offset": {}, + "output": {}, + "place_id": { + "required": true + }, + "rating": {}, + "sort_by": { + "type": "select", + "options": [ + "most_recent", + "detailed_review" + ] + }, + "tripadvisor_domain": { + "type": "select", + "options": [ + "www.tripadvisor.com", + "ar.tripadvisor.com", + "www.tripadvisor.com.ar", + "www.tripadvisor.com.au", + "www.tripadvisor.at", + "www.tripadvisor.be", + "fr.tripadvisor.be", + "www.tripadvisor.com.br", + "www.tripadvisor.ca", + "fr.tripadvisor.ca", + "www.tripadvisor.cl", + "cn.tripadvisor.com", + "www.tripadvisor.co", + "www.tripadvisor.com.pe", + "www.tripadvisor.dk", + "www.tripadvisor.com.eg", + "www.tripadvisor.fr", + "www.tripadvisor.de", + "www.tripadvisor.com.gr", + "www.tripadvisor.com.hk", + "en.tripadvisor.com.hk", + "www.tripadvisor.in", + "www.tripadvisor.co.id", + "www.tripadvisor.ie", + "www.tripadvisor.co.il", + "www.tripadvisor.it", + "www.tripadvisor.jp", + "www.tripadvisor.co.kr", + "www.tripadvisor.com.my", + "www.tripadvisor.com.mx", + "www.tripadvisor.nl", + "www.tripadvisor.co.nz", + "no.tripadvisor.com", + "www.tripadvisor.com.ph", + "www.tripadvisor.pt", + "www.tripadvisor.ru", + "www.tripadvisor.com.sg", + "www.tripadvisor.co.za", + "www.tripadvisor.es", + "www.tripadvisor.se", + "fr.tripadvisor.ch", + "www.tripadvisor.ch", + "it.tripadvisor.ch", + "www.tripadvisor.com.tw", + "th.tripadvisor.com", + "www.tripadvisor.com.tr", + "www.tripadvisor.co.uk", + "www.tripadvisor.com.ve", + "www.tripadvisor.com.vn" + ] + }, + "type_of_visit": { + "value_type": "string" + }, + "zero_trace": {} + }, + "walmart": { + "api_key": { + "required": true + }, + "async": {}, + "cat_id": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "facet": {}, + "include_filters": { + "type": "checkbox" + }, + "json_restrictor": {}, + "max_price": { + "type": "number" + }, + "min_price": { + "type": "number" + }, + "nd_en": { + "type": "checkbox" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "query": { + "required": true + }, + "soft_sort": { + "type": "checkbox" + }, + "sort": { + "type": "select", + "options": [ + "price_low", + "price_high", + "best_seller", + "best_match", + "rating_high" + ] + }, + "spelling": { + "type": "checkbox" + }, + "store_id": {}, + "walmart_domain": { + "type": "select", + "options": [ + "walmart.com", + "walmart.com.mx" + ] + }, + "zero_trace": {} + }, + "walmart_product": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "store_id": {}, + "zero_trace": {} + }, + "walmart_product_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "product_id": { + "required": true + }, + "rating": { + "type": "select", + "value_type": "number" + }, + "sort": { + "type": "select", + "options": [ + "relevancy", + "helpful", + "submission-desc", + "submission-asc", + "rating-desc", + "rating-asc" + ] + }, + "zero_trace": {} + }, + "walmart_product_sellers": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "product_id": { + "required": true + }, + "store_id": { + "required": true + }, + "zero_trace": {} + }, + "walmart_seller": { + "api_key": { + "required": true + }, + "async": {}, + "catalog_seller_id": { + "required": true + }, + "engine": { + "required": true + }, + "facet": {}, + "include_filters": { + "type": "checkbox" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "sort": { + "type": "select", + "options": [ + "best_match", + "price_low", + "price_high", + "best_seller", + "rating_high", + "new" + ] + }, + "zero_trace": {} + }, + "yahoo": { + "api_key": { + "required": true + }, + "async": {}, + "b": { + "type": "number" + }, + "d": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "fr2": {}, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "p": { + "required": true + }, + "vc": { + "type": "select", + "value_type": "string" + }, + "vf": { + "type": "select", + "options": [ + "html", + "pdf", + "xls", + "ppt", + "doc", + "txt" + ] + }, + "vl": { + "type": "select", + "options": [ + "lang_ar", + "lang_bg", + "lang_zh_chs", + "lang_zh_cht", + "lang_hr", + "lang_cs", + "lang_da", + "lang_nl", + "lang_en", + "lang_et", + "lang_fi", + "lang_fr", + "lang_de", + "lang_el", + "lang_he", + "lang_hu", + "lang_it", + "lang_ja", + "lang_ko", + "lang_lv", + "lang_lt", + "lang_no", + "lang_pl", + "lang_pt", + "lang_ro", + "lang_ru", + "lang_sk", + "lang_sl", + "lang_es", + "lang_sv", + "lang_th", + "lang_tr" + ] + }, + "vm": { + "type": "select", + "options": [ + "r", + "i", + "p" + ] + }, + "vs": {}, + "yahoo_domain": { + "type": "select", + "options": [ + "espanol", + "be", + "fr", + "br", + "ca", + "de", + "es", + "in", + "id", + "ie", + "it", + "malaysia", + "nl", + "no", + "at", + "ph", + "pl", + "qc", + "ro", + "ch", + "sg", + "za", + "fi", + "se", + "tr", + "uk", + "vn", + "gr", + "ru", + "ua", + "il", + "hk", + "tw" + ] + }, + "zero_trace": {} + }, + "yahoo_images": { + "api_key": { + "required": true + }, + "async": {}, + "b": { + "type": "number" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "engine": { + "required": true + }, + "imga": { + "type": "select", + "options": [ + "square", + "wide", + "tall" + ] + }, + "imgc": { + "type": "select", + "options": [ + "color", + "bw", + "red", + "orange", + "yellow", + "green", + "teal", + "blue", + "purple", + "pink", + "brown", + "black", + "gray", + "white" + ] + }, + "imgf": { + "type": "select", + "options": [ + "face", + "portrait", + "nonportrait" + ] + }, + "imgl": { + "type": "select", + "options": [ + "cc", + "pd", + "fsu", + "fsuc", + "fmsu", + "fmsuc" + ] + }, + "imgsz": { + "type": "select", + "options": [ + "small", + "medium", + "large", + "wallpaper" + ] + }, + "imgt": { + "type": "select", + "options": [ + "day", + "week", + "month", + "year" + ] + }, + "imgty": { + "type": "select", + "options": [ + "photo", + "clipart", + "linedrawing", + "gif", + "transparent" + ] + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "p": { + "required": true + }, + "yahoo_domain": { + "type": "select", + "options": [ + "espanol", + "fr", + "br", + "ca", + "de", + "es", + "in", + "id", + "it", + "malaysia", + "nl", + "no", + "at", + "ph", + "qc", + "ch", + "sg", + "fi", + "se", + "uk", + "vn", + "ru", + "hk", + "tw" + ] + }, + "zero_trace": {} + }, + "yahoo_shopping": { + "api_key": { + "required": true + }, + "async": {}, + "category_attr_values": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "limit": {}, + "max_price": {}, + "merchants": {}, + "min_price": {}, + "no_cache": { + "type": "checkbox" + }, + "order_by": { + "type": "select", + "options": [ + "ASC", + "DESC" + ] + }, + "output": {}, + "p": { + "required": true + }, + "page": {}, + "sort_by": { + "type": "select", + "options": [ + "price", + "relevancy", + "popularity", + "discountPercentage" + ] + }, + "start": {}, + "zero_trace": {} + }, + "yahoo_trends": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "full_video_links": { + "type": "checkbox" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "zero_trace": {} + }, + "yahoo_videos": { + "api_key": { + "required": true + }, + "async": {}, + "b": { + "type": "number" + }, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "durs": { + "type": "select", + "options": [ + "short", + "medium", + "long" + ] + }, + "engine": { + "required": true + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "p": { + "required": true + }, + "vage": { + "type": "select", + "options": [ + "day", + "week", + "month", + "year" + ] + }, + "vres": { + "type": "select", + "options": [ + "360p", + "480p", + "720p", + "1080p" + ] + }, + "vsite": { + "type": "select", + "options": [ + "youtube", + "dailymotion", + "vimeo", + "mtv", + "cbsnews", + "foxnews", + "cnn", + "msn" + ] + }, + "yahoo_domain": { + "type": "select", + "options": [ + "espanol", + "be", + "fr", + "br", + "ca", + "de", + "es", + "in", + "id", + "ie", + "it", + "malaysia", + "nl", + "no", + "at", + "ph", + "pl", + "qc", + "ro", + "ch", + "sg", + "za", + "fi", + "se", + "tr", + "uk", + "vn", + "gr", + "ru", + "ua", + "il", + "hk", + "tw" + ] + }, + "zero_trace": {} + }, + "yandex": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "family_mode": { + "type": "select", + "value_type": "number" + }, + "fix_typo": { + "type": "select", + "options": [ + "false", + "true" + ] + }, + "groups_on_page": { + "type": "number" + }, + "json_restrictor": {}, + "lang": { + "type": "select", + "options": [ + "ru", + "en", + "be", + "kk", + "tr", + "uk" + ] + }, + "lr": { + "type": "select", + "value_type": "number" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "p": { + "type": "number" + }, + "period": { + "type": "select", + "options": [ + "all", + "day", + "last_two_weeks", + "month" + ] + }, + "sort_mode": { + "type": "select", + "options": [ + "relevance", + "time" + ] + }, + "text": { + "required": true + }, + "yandex_domain": { + "type": "select", + "options": [ + "yandex.com", + "yandex.ru", + "yandex.by", + "yandex.kz", + "yandex.uz", + "yandex.com.tr" + ] + }, + "zero_trace": {} + }, + "yandex_images": { + "api_key": { + "required": true + }, + "async": {}, + "color": { + "type": "select", + "options": [ + "color", + "gray", + "red", + "orange", + "yellow", + "cyan", + "green", + "blue", + "violet", + "white", + "black" + ] + }, + "crop": {}, + "crop_id": { + "type": "number" + }, + "engine": { + "required": true + }, + "family_mode": { + "type": "select", + "value_type": "number" + }, + "file_type": { + "type": "select", + "options": [ + "jpg", + "png", + "gifan" + ] + }, + "height": { + "type": "number" + }, + "image_type": { + "type": "select", + "options": [ + "photo", + "clipart", + "lineart", + "face", + "demotivator" + ] + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "orientation": { + "type": "select", + "options": [ + "horizontal", + "vertical", + "square" + ] + }, + "output": {}, + "p": { + "type": "number" + }, + "recent": { + "type": "checkbox" + }, + "site": {}, + "tab": { + "type": "select", + "options": [ + "about", + "similar" + ] + }, + "text": { + "required": true + }, + "url": {}, + "width": { + "type": "number" + }, + "yandex_domain": { + "type": "select", + "options": [ + "yandex.com", + "yandex.ru", + "yandex.by", + "yandex.kz", + "yandex.uz", + "yandex.com.tr" + ] + }, + "zero_trace": {} + }, + "yandex_videos": { + "api_key": { + "required": true + }, + "async": {}, + "device": { + "type": "device", + "options": [ + "desktop", + "tablet", + "mobile" + ] + }, + "duration": { + "type": "select", + "options": [ + "short", + "medium", + "long" + ] + }, + "engine": { + "required": true + }, + "hd": { + "type": "checkbox" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "p": { + "type": "number" + }, + "text": { + "required": true + }, + "within": { + "type": "select", + "value_type": "number" + }, + "yandex_domain": { + "type": "select", + "options": [ + "yandex.com", + "yandex.ru", + "yandex.by", + "yandex.kz", + "yandex.uz", + "yandex.com.tr" + ] + }, + "zero_trace": {} + }, + "yelp": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "find_desc": {}, + "find_loc": { + "required": true + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "sortby": { + "type": "select", + "options": [ + "recommended", + "rating", + "review_count" + ] + }, + "start": { + "type": "number" + }, + "yelp_domain": { + "type": "select", + "options": [ + "ms.yelp.my", + "www.yelp.cz", + "www.yelp.dk", + "www.yelp.de", + "www.yelp.at", + "de.yelp.ch", + "www.yelp.com.au", + "en.yelp.be", + "www.yelp.ca", + "en.yelp.com.hk", + "en.yelp.my", + "www.yelp.co.nz", + "en.yelp.com.ph", + "www.yelp.ie", + "www.yelp.com.sg", + "en.yelp.ch", + "www.yelp.co.uk", + "www.yelp.com", + "www.yelp.com.ar", + "www.yelp.cl", + "www.yelp.es", + "www.yelp.com.mx", + "fil.yelp.com.ph", + "fr.yelp.be", + "fr.yelp.ca", + "www.yelp.fr", + "fr.yelp.ch", + "www.yelp.it", + "it.yelp.ch", + "nl.yelp.be", + "www.yelp.nl", + "www.yelp.no", + "www.yelp.pl", + "www.yelp.com.br", + "www.yelp.pt", + "fi.yelp.fi", + "sv.yelp.fi", + "www.yelp.com.tr", + "www.yelp.co.jp", + "zh.yelp.com.hk", + "www.yelp.com.tw" + ] + }, + "zero_trace": {} + }, + "yelp_place": { + "api_key": { + "required": true + }, + "async": {}, + "business_alert": { + "type": "checkbox" + }, + "engine": { + "required": true + }, + "full_menu": { + "type": "checkbox" + }, + "json_restrictor": {}, + "menu_name": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "place_id": { + "required": true + }, + "yelp_domain": { + "type": "select", + "options": [ + "ms.yelp.my", + "www.yelp.cz", + "www.yelp.dk", + "www.yelp.de", + "www.yelp.at", + "de.yelp.ch", + "www.yelp.com.au", + "en.yelp.be", + "www.yelp.ca", + "en.yelp.com.hk", + "en.yelp.my", + "www.yelp.co.nz", + "en.yelp.com.ph", + "www.yelp.ie", + "www.yelp.com.sg", + "en.yelp.ch", + "www.yelp.co.uk", + "www.yelp.com", + "www.yelp.com.ar", + "www.yelp.cl", + "www.yelp.es", + "www.yelp.com.mx", + "fil.yelp.com.ph", + "fr.yelp.be", + "fr.yelp.ca", + "www.yelp.fr", + "fr.yelp.ch", + "www.yelp.it", + "it.yelp.ch", + "nl.yelp.be", + "www.yelp.nl", + "www.yelp.no", + "www.yelp.pl", + "www.yelp.com.br", + "www.yelp.pt", + "fi.yelp.fi", + "sv.yelp.fi", + "www.yelp.com.tr", + "www.yelp.co.jp", + "zh.yelp.com.hk", + "www.yelp.com.tw" + ] + }, + "zero_trace": {} + }, + "yelp_reviews": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "hl": { + "type": "select", + "options": [ + "ms", + "cs", + "da", + "de", + "en", + "es", + "fil", + "fr", + "it", + "nl", + "nb", + "pl", + "pt", + "fi", + "sv", + "tr", + "ja", + "zh" + ] + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "not_recommended": { + "type": "checkbox" + }, + "not_recommended_start": { + "type": "number" + }, + "num": { + "type": "number" + }, + "output": {}, + "place_id": { + "required": true + }, + "q": {}, + "rating": {}, + "sortby": { + "type": "select", + "options": [ + "relevance_desc", + "date_desc", + "date_asc", + "rating_desc", + "rating_asc", + "elites_desc" + ] + }, + "start": { + "type": "number" + }, + "yelp_domain": { + "type": "select", + "options": [ + "ms.yelp.my", + "www.yelp.cz", + "www.yelp.dk", + "www.yelp.de", + "www.yelp.at", + "de.yelp.ch", + "www.yelp.com.au", + "en.yelp.be", + "www.yelp.ca", + "en.yelp.com.hk", + "en.yelp.my", + "www.yelp.co.nz", + "en.yelp.com.ph", + "www.yelp.ie", + "www.yelp.com.sg", + "en.yelp.ch", + "www.yelp.co.uk", + "www.yelp.com", + "www.yelp.com.ar", + "www.yelp.cl", + "www.yelp.es", + "www.yelp.com.mx", + "fil.yelp.com.ph", + "fr.yelp.be", + "fr.yelp.ca", + "www.yelp.fr", + "fr.yelp.ch", + "www.yelp.it", + "it.yelp.ch", + "nl.yelp.be", + "www.yelp.nl", + "www.yelp.no", + "www.yelp.pl", + "www.yelp.com.br", + "www.yelp.pt", + "fi.yelp.fi", + "sv.yelp.fi", + "www.yelp.com.tr", + "www.yelp.co.jp", + "zh.yelp.com.hk", + "www.yelp.com.tw" + ] + }, + "zero_trace": {} + }, + "youtube": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "search_query": { + "required": true + }, + "sp": {}, + "zero_trace": {} + }, + "youtube_channel": { + "about": { + "type": "checkbox" + }, + "api_key": { + "required": true + }, + "async": {}, + "channel_id": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "options": [ + "af", + "am", + "ar", + "az", + "be", + "bg", + "bn", + "bs", + "ca", + "cs", + "da", + "de", + "el", + "en", + "es", + "es-419", + "et", + "eu", + "fa", + "fi", + "fr", + "gl", + "gu", + "he", + "hi", + "hr", + "hu", + "hy", + "id", + "is", + "it", + "iw", + "ja", + "ka", + "kk", + "km", + "kn", + "ko", + "ky", + "lo", + "lt", + "lv", + "mk", + "ml", + "mn", + "mo", + "mr", + "ms", + "my", + "ne", + "nl", + "no", + "or", + "pa", + "pl", + "pt", + "pt-br", + "pt-pt", + "ro", + "ru", + "sh", + "si", + "sk", + "sl", + "sq", + "sr", + "sv", + "sw", + "ta", + "te", + "th", + "tl", + "tr", + "uk", + "ur", + "uz", + "vi", + "zh-cn", + "zh-tw", + "zu" + ] + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "search_query": {}, + "sort": { + "type": "select", + "options": [ + "latest", + "popular", + "oldest", + "dd", + "lad" + ] + }, + "tab": { + "type": "select", + "options": [ + "home", + "videos", + "shorts", + "streams", + "podcasts", + "playlists", + "posts" + ] + }, + "zero_trace": {} + }, + "youtube_video": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "gl": { + "type": "select", + "value_type": "string" + }, + "hl": { + "type": "select", + "value_type": "string" + }, + "json_restrictor": {}, + "next_page_token": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "v": {}, + "zero_trace": {} + }, + "youtube_video_transcript": { + "api_key": { + "required": true + }, + "async": {}, + "engine": { + "required": true + }, + "json_restrictor": {}, + "language_code": { + "type": "select", + "value_type": "string" + }, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "title": {}, + "type": { + "type": "select", + "options": [ + "asr" + ] + }, + "v": { + "required": true + }, + "zero_trace": {} + }, + "zillow": { + "age_55_plus": { + "type": "select", + "options": [ + "include", + "exclude", + "only" + ] + }, + "amenities": {}, + "api_key": { + "required": true + }, + "async": {}, + "basement": {}, + "baths": {}, + "beds": {}, + "engine": { + "required": true + }, + "has_garage": { + "type": "checkbox" + }, + "hide_no_date_listings": { + "type": "checkbox" + }, + "hoa_max": { + "type": "number" + }, + "home_type": {}, + "json_restrictor": {}, + "keywords": {}, + "listing_features": {}, + "listing_status": {}, + "listing_type": {}, + "lot_size": {}, + "map_bounds": {}, + "move_in_date": {}, + "no_cache": { + "type": "checkbox" + }, + "output": {}, + "page": { + "type": "number" + }, + "parking_spots": { + "type": "number" + }, + "pets": {}, + "price": {}, + "price_reduction": { + "type": "checkbox" + }, + "region_id": {}, + "short_term_lease": { + "type": "checkbox" + }, + "single_story": { + "type": "checkbox" + }, + "sort_by": { + "type": "select", + "options": [ + "globalrelevanceex", + "featured", + "priced", + "pricea", + "paymentd", + "paymenta", + "days", + "beds", + "baths", + "size", + "lot", + "priorityscore" + ] + }, + "space": { + "type": "select", + "options": [ + "any", + "entire_place", + "room" + ] + }, + "sqft": {}, + "status_type": { + "type": "select", + "options": [ + "sale", + "rent", + "sold" + ] + }, + "time_on_zillow": {}, + "tours": {}, + "view": {}, + "year_built": {}, + "zero_trace": {} + } + } +} diff --git a/stubs/pyproject.toml b/stubs/pyproject.toml new file mode 100644 index 0000000..ef3a029 --- /dev/null +++ b/stubs/pyproject.toml @@ -0,0 +1,50 @@ +[build-system] +requires = ["setuptools>=77"] +build-backend = "setuptools.build_meta" + +[project] +name = "serpapi-stubs" +dynamic = ["version"] +description = "Type stubs for the official SerpApi Python client (serpapi)." +readme = "README.md" +license = "MIT" +license-files = ["LICENSE"] +authors = [{ name = "SerpApi", email = "support@serpapi.com" }] +requires-python = ">=3.6" +dependencies = ["types-requests"] +keywords = ["serpapi", "stubs", "typing", "mypy", "pyright"] +classifiers = [ + "Programming Language :: Python :: 3", + "Typing :: Stubs Only", + "Intended Audience :: Developers", + "Topic :: Software Development :: Libraries :: Python Modules", +] + +[project.urls] +Homepage = "https://github.com/serpapi/serpapi-python/tree/master/stubs" +Source = "https://github.com/serpapi/serpapi-python" +Documentation = "https://serpapi-python.readthedocs.io/en/latest/" + +[tool.setuptools] +packages = ["serpapi-stubs"] +include-package-data = false + +[tool.setuptools.package-data] +"serpapi-stubs" = ["*.pyi"] + +[tool.setuptools.dynamic] +version = { file = "VERSION" } + +[tool.pytest.ini_options] +testpaths = ["tests"] + +[tool.mypy] +files = ["tests/typecheck"] +strict = true +warn_unused_ignores = true + +[tool.pyright] +include = ["tests/typecheck"] +typeCheckingMode = "strict" +enableTypeIgnoreComments = true +reportUnnecessaryTypeIgnoreComment = "error" diff --git a/stubs/serpapi-stubs/__init__.pyi b/stubs/serpapi-stubs/__init__.pyi new file mode 100644 index 0000000..062a312 --- /dev/null +++ b/stubs/serpapi-stubs/__init__.pyi @@ -0,0 +1,20 @@ +from .__version__ import __version__ as __version__ +from .core import ( + Client as Client, + account as account, + extract as extract, + locations as locations, + search as search, + search_archive as search_archive, + upload_image as upload_image, +) +from .exceptions import ( + APIKeyNotProvided as APIKeyNotProvided, + HTTPConnectionError as HTTPConnectionError, + HTTPError as HTTPError, + SearchIDNotProvided as SearchIDNotProvided, + SerpApiError as SerpApiError, + TimeoutError as TimeoutError, +) +from .http import HTTPClient as HTTPClient +from .models import SerpResults as SerpResults diff --git a/stubs/serpapi-stubs/__version__.pyi b/stubs/serpapi-stubs/__version__.pyi new file mode 100644 index 0000000..bda5b5a --- /dev/null +++ b/stubs/serpapi-stubs/__version__.pyi @@ -0,0 +1 @@ +__version__: str diff --git a/stubs/serpapi-stubs/core.pyi b/stubs/serpapi-stubs/core.pyi new file mode 100644 index 0000000..cb0e2f9 --- /dev/null +++ b/stubs/serpapi-stubs/core.pyi @@ -0,0 +1,24515 @@ +# Generated by stubs/tools/generate_stubs.py from stubs/data/engines.json. +# Do not edit by hand; run `python stubs/tools/generate_stubs.py` instead. + +from os import PathLike +from typing import IO, Any, Dict, List, Mapping, MutableMapping, Optional, Union, overload +from typing_extensions import Literal + +from .engine_params import ( + AirbnbJsonSearchParams, + AirbnbTextSearchParams, + AmazonAutocompleteJsonSearchParams, + AmazonAutocompleteTextSearchParams, + AmazonFreshJsonSearchParams, + AmazonFreshTextSearchParams, + AmazonJsonSearchParams, + AmazonProductJsonSearchParams, + AmazonProductTextSearchParams, + AmazonPromotionJsonSearchParams, + AmazonPromotionTextSearchParams, + AmazonTextSearchParams, + AppleAppStoreJsonSearchParams, + AppleAppStoreTextSearchParams, + AppleMapsJsonSearchParams, + AppleMapsPlacesJsonSearchParams, + AppleMapsPlacesTextSearchParams, + AppleMapsTextSearchParams, + AppleProductJsonSearchParams, + AppleProductTextSearchParams, + AppleReviewsJsonSearchParams, + AppleReviewsTextSearchParams, + AutozoneJsonSearchParams, + AutozoneProductJsonSearchParams, + AutozoneProductTextSearchParams, + AutozoneTextSearchParams, + BaiduJsonSearchParams, + BaiduMapsJsonSearchParams, + BaiduMapsTextSearchParams, + BaiduNewsJsonSearchParams, + BaiduNewsTextSearchParams, + BaiduTextSearchParams, + BingCopilotJsonSearchParams, + BingCopilotTextSearchParams, + BingImagesJsonSearchParams, + BingImagesTextSearchParams, + BingJsonSearchParams, + BingMapsJsonSearchParams, + BingMapsTextSearchParams, + BingNewsJsonSearchParams, + BingNewsTextSearchParams, + BingProductJsonSearchParams, + BingProductTextSearchParams, + BingReverseImageJsonSearchParams, + BingReverseImageTextSearchParams, + BingShoppingJsonSearchParams, + BingShoppingTextSearchParams, + BingTextSearchParams, + BingVideosJsonSearchParams, + BingVideosTextSearchParams, + BookingJsonSearchParams, + BookingTextSearchParams, + BraveAiModeJsonSearchParams, + BraveAiModeTextSearchParams, + BraveImagesJsonSearchParams, + BraveImagesTextSearchParams, + BraveJsonSearchParams, + BraveTextSearchParams, + BraveVideosJsonSearchParams, + BraveVideosTextSearchParams, + DoordashJsonSearchParams, + DoordashTextSearchParams, + DuckAiJsonSearchParams, + DuckAiTextSearchParams, + DuckduckgoJsonSearchParams, + DuckduckgoLightJsonSearchParams, + DuckduckgoLightTextSearchParams, + DuckduckgoMapsJsonSearchParams, + DuckduckgoMapsTextSearchParams, + DuckduckgoNewsJsonSearchParams, + DuckduckgoNewsTextSearchParams, + DuckduckgoShoppingJsonSearchParams, + DuckduckgoShoppingTextSearchParams, + DuckduckgoTextSearchParams, + EbayJsonSearchParams, + EbayProductJsonSearchParams, + EbayProductTextSearchParams, + EbaySellerJsonSearchParams, + EbaySellerTextSearchParams, + EbayTextSearchParams, + EventbriteJsonSearchParams, + EventbriteTextSearchParams, + ExtractJsonParams, + ExtractJsonSearchParams, + ExtractTextParams, + ExtractTextSearchParams, + FacebookMarketplaceJsonSearchParams, + FacebookMarketplaceTextSearchParams, + FacebookProfileJsonSearchParams, + FacebookProfileTextSearchParams, + Flightradar24JsonSearchParams, + Flightradar24TextSearchParams, + GlassdoorCompaniesJsonSearchParams, + GlassdoorCompaniesTextSearchParams, + GlassdoorJobsJsonSearchParams, + GlassdoorJobsTextSearchParams, + GlassdoorReviewsJsonSearchParams, + GlassdoorReviewsTextSearchParams, + GoogleAboutThisResultJsonSearchParams, + GoogleAboutThisResultTextSearchParams, + GoogleAdsJsonSearchParams, + GoogleAdsTextSearchParams, + GoogleAdsTransparencyCenterAdDetailsJsonSearchParams, + GoogleAdsTransparencyCenterAdDetailsTextSearchParams, + GoogleAdsTransparencyCenterJsonSearchParams, + GoogleAdsTransparencyCenterTextSearchParams, + GoogleAiModeJsonSearchParams, + GoogleAiModeTextSearchParams, + GoogleAiOverviewJsonSearchParams, + GoogleAiOverviewTextSearchParams, + GoogleAutocompleteJsonSearchParams, + GoogleAutocompleteTextSearchParams, + GoogleBooksJsonSearchParams, + GoogleBooksTextSearchParams, + GoogleEventDetailsJsonSearchParams, + GoogleEventDetailsTextSearchParams, + GoogleEventsJsonSearchParams, + GoogleEventsTextSearchParams, + GoogleFinanceAutocompleteJsonSearchParams, + GoogleFinanceAutocompleteTextSearchParams, + GoogleFinanceJsonSearchParams, + GoogleFinanceMarketsJsonSearchParams, + GoogleFinanceMarketsTextSearchParams, + GoogleFinanceTextSearchParams, + GoogleFlightsAutocompleteJsonSearchParams, + GoogleFlightsAutocompleteTextSearchParams, + GoogleFlightsCalendarJsonSearchParams, + GoogleFlightsCalendarTextSearchParams, + GoogleFlightsDealsJsonSearchParams, + GoogleFlightsDealsTextSearchParams, + GoogleFlightsJsonSearchParams, + GoogleFlightsTextSearchParams, + GoogleForumsJsonSearchParams, + GoogleForumsTextSearchParams, + GoogleGeminiJsonSearchParams, + GoogleGeminiTextSearchParams, + GoogleHotelsAutocompleteJsonSearchParams, + GoogleHotelsAutocompleteTextSearchParams, + GoogleHotelsJsonSearchParams, + GoogleHotelsPhotosJsonSearchParams, + GoogleHotelsPhotosTextSearchParams, + GoogleHotelsPriceCalendarJsonSearchParams, + GoogleHotelsPriceCalendarTextSearchParams, + GoogleHotelsReviewsJsonSearchParams, + GoogleHotelsReviewsTextSearchParams, + GoogleHotelsTextSearchParams, + GoogleImagesJsonSearchParams, + GoogleImagesLightJsonSearchParams, + GoogleImagesLightTextSearchParams, + GoogleImagesRelatedContentJsonSearchParams, + GoogleImagesRelatedContentTextSearchParams, + GoogleImagesTextSearchParams, + GoogleImmersiveProductJsonSearchParams, + GoogleImmersiveProductTextSearchParams, + GoogleJobsJsonSearchParams, + GoogleJobsListingJsonSearchParams, + GoogleJobsListingTextSearchParams, + GoogleJobsTextSearchParams, + GoogleJsonSearchParams, + GoogleLensJsonSearchParams, + GoogleLensTextSearchParams, + GoogleLightJsonSearchParams, + GoogleLightTextSearchParams, + GoogleLocalJsonSearchParams, + GoogleLocalServicesJsonSearchParams, + GoogleLocalServicesTextSearchParams, + GoogleLocalTextSearchParams, + GoogleMapsAutocompleteJsonSearchParams, + GoogleMapsAutocompleteTextSearchParams, + GoogleMapsContributorReviewsJsonSearchParams, + GoogleMapsContributorReviewsTextSearchParams, + GoogleMapsDirectionsJsonSearchParams, + GoogleMapsDirectionsTextSearchParams, + GoogleMapsJsonSearchParams, + GoogleMapsPhotoMetaJsonSearchParams, + GoogleMapsPhotoMetaTextSearchParams, + GoogleMapsPhotosJsonSearchParams, + GoogleMapsPhotosTextSearchParams, + GoogleMapsPostsJsonSearchParams, + GoogleMapsPostsTextSearchParams, + GoogleMapsReviewsJsonSearchParams, + GoogleMapsReviewsTextSearchParams, + GoogleMapsTextSearchParams, + GoogleNewsJsonSearchParams, + GoogleNewsLightJsonSearchParams, + GoogleNewsLightTextSearchParams, + GoogleNewsTextSearchParams, + GooglePatentsDetailsJsonSearchParams, + GooglePatentsDetailsTextSearchParams, + GooglePatentsJsonSearchParams, + GooglePatentsTextSearchParams, + GooglePlayBooksJsonSearchParams, + GooglePlayBooksTextSearchParams, + GooglePlayGamesJsonSearchParams, + GooglePlayGamesTextSearchParams, + GooglePlayJsonSearchParams, + GooglePlayMoviesJsonSearchParams, + GooglePlayMoviesTextSearchParams, + GooglePlayProductJsonSearchParams, + GooglePlayProductTextSearchParams, + GooglePlayTextSearchParams, + GoogleProductJsonSearchParams, + GoogleProductTextSearchParams, + GoogleRelatedQuestionsJsonSearchParams, + GoogleRelatedQuestionsTextSearchParams, + GoogleReverseImageJsonSearchParams, + GoogleReverseImageTextSearchParams, + GoogleScholarAuthorJsonSearchParams, + GoogleScholarAuthorTextSearchParams, + GoogleScholarCaseLawJsonSearchParams, + GoogleScholarCaseLawTextSearchParams, + GoogleScholarCiteJsonSearchParams, + GoogleScholarCiteTextSearchParams, + GoogleScholarJsonSearchParams, + GoogleScholarTextSearchParams, + GoogleShoppingFiltersJsonSearchParams, + GoogleShoppingFiltersTextSearchParams, + GoogleShoppingJsonSearchParams, + GoogleShoppingLightJsonSearchParams, + GoogleShoppingLightTextSearchParams, + GoogleShoppingTextSearchParams, + GoogleShortVideosJsonSearchParams, + GoogleShortVideosTextSearchParams, + GoogleSportsJsonSearchParams, + GoogleSportsTextSearchParams, + GoogleTextSearchParams, + GoogleTranslateJsonSearchParams, + GoogleTranslateTextSearchParams, + GoogleTravelExploreJsonSearchParams, + GoogleTravelExploreTextSearchParams, + GoogleTrendsAutocompleteJsonSearchParams, + GoogleTrendsAutocompleteTextSearchParams, + GoogleTrendsJsonSearchParams, + GoogleTrendsNewsJsonSearchParams, + GoogleTrendsNewsTextSearchParams, + GoogleTrendsTextSearchParams, + GoogleTrendsTrendingNowJsonSearchParams, + GoogleTrendsTrendingNowTextSearchParams, + GoogleVideosJsonSearchParams, + GoogleVideosLightJsonSearchParams, + GoogleVideosLightTextSearchParams, + GoogleVideosTextSearchParams, + HomeDepotJsonSearchParams, + HomeDepotProductJsonSearchParams, + HomeDepotProductReviewsJsonSearchParams, + HomeDepotProductReviewsTextSearchParams, + HomeDepotProductTextSearchParams, + HomeDepotTextSearchParams, + IndeedJobsJsonSearchParams, + IndeedJobsTextSearchParams, + InstagramPopularJsonSearchParams, + InstagramPopularTextSearchParams, + InstagramProfileJsonSearchParams, + InstagramProfileTextSearchParams, + MetaAdLibraryJsonSearchParams, + MetaAdLibraryTextSearchParams, + NapaJsonSearchParams, + NapaTextSearchParams, + NaverAiModeJsonSearchParams, + NaverAiModeTextSearchParams, + NaverAiOverviewJsonSearchParams, + NaverAiOverviewTextSearchParams, + NaverJsonSearchParams, + NaverMapsJsonSearchParams, + NaverMapsTextSearchParams, + NaverTextSearchParams, + OpenTableReviewsJsonSearchParams, + OpenTableReviewsTextSearchParams, + PinterestJsonSearchParams, + PinterestTextSearchParams, + SearchArchiveJsonParams, + SearchArchiveParams, + SearchArchiveTextParams, + SearchIndexJsonSearchParams, + SearchIndexTextSearchParams, + SearchParams, + TargetJsonSearchParams, + TargetTextSearchParams, + TiktokDiscoverJsonSearchParams, + TiktokDiscoverTextSearchParams, + TiktokShopJsonSearchParams, + TiktokShopTextSearchParams, + TraderJoesJsonSearchParams, + TraderJoesProductJsonSearchParams, + TraderJoesProductTextSearchParams, + TraderJoesTextSearchParams, + TripadvisorJsonSearchParams, + TripadvisorPlaceJsonSearchParams, + TripadvisorPlaceTextSearchParams, + TripadvisorReviewsJsonSearchParams, + TripadvisorReviewsTextSearchParams, + TripadvisorTextSearchParams, + WalmartJsonSearchParams, + WalmartProductJsonSearchParams, + WalmartProductReviewsJsonSearchParams, + WalmartProductReviewsTextSearchParams, + WalmartProductSellersJsonSearchParams, + WalmartProductSellersTextSearchParams, + WalmartProductTextSearchParams, + WalmartSellerJsonSearchParams, + WalmartSellerTextSearchParams, + WalmartTextSearchParams, + YahooImagesJsonSearchParams, + YahooImagesTextSearchParams, + YahooJsonSearchParams, + YahooShoppingJsonSearchParams, + YahooShoppingTextSearchParams, + YahooTextSearchParams, + YahooTrendsJsonSearchParams, + YahooTrendsTextSearchParams, + YahooVideosJsonSearchParams, + YahooVideosTextSearchParams, + YandexImagesJsonSearchParams, + YandexImagesTextSearchParams, + YandexJsonSearchParams, + YandexTextSearchParams, + YandexVideosJsonSearchParams, + YandexVideosTextSearchParams, + YelpJsonSearchParams, + YelpPlaceJsonSearchParams, + YelpPlaceTextSearchParams, + YelpReviewsJsonSearchParams, + YelpReviewsTextSearchParams, + YelpTextSearchParams, + YoutubeChannelJsonSearchParams, + YoutubeChannelTextSearchParams, + YoutubeJsonSearchParams, + YoutubeTextSearchParams, + YoutubeVideoJsonSearchParams, + YoutubeVideoTextSearchParams, + YoutubeVideoTranscriptJsonSearchParams, + YoutubeVideoTranscriptTextSearchParams, + ZillowJsonSearchParams, + ZillowTextSearchParams, + _Flag, + _Number, + _Scalar, +) +from .http import HTTPClient, _Cert, _Proxies, _Timeout, _Verify +from .models import SerpResults + +class Client(HTTPClient): + DASHBOARD_URL: str + def __init__(self, *, api_key: Optional[str] = None, timeout: _Timeout = None) -> None: ... + def __repr__(self) -> str: ... + @overload + def search( + self, + params: AirbnbTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AirbnbJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["airbnb"], + output: Literal["html", "md"], + accessibility_features: _Scalar = ..., + adults: _Number = ..., + airbnb_domain: str = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + beds: _Number = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + currency: Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"] = ..., + guest_favorite: _Flag = ..., + host_languages: _Scalar = ..., + infants: _Number = ..., + instant_book: _Flag = ..., + json_restrictor: _Scalar = ..., + luxe: _Flag = ..., + map_bounds: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pets: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + room_type: Literal["entire_home", "private_room"] = ..., + self_check_in: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["airbnb"], + accessibility_features: _Scalar = ..., + adults: _Number = ..., + airbnb_domain: str = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + beds: _Number = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + currency: Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"] = ..., + guest_favorite: _Flag = ..., + host_languages: _Scalar = ..., + infants: _Number = ..., + instant_book: _Flag = ..., + json_restrictor: _Scalar = ..., + luxe: _Flag = ..., + map_bounds: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pets: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + room_type: Literal["entire_home", "private_room"] = ..., + self_check_in: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AmazonTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AmazonJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + emi: _Scalar = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + emi: _Scalar = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AmazonAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AmazonAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_autocomplete"], + output: Literal["html", "md"], + amazon_department: Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"] = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_autocomplete"], + amazon_department: Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"] = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AmazonFreshTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AmazonFreshJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_fresh"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_fresh"], + amazon_domain: Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AmazonProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AmazonProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_product"], + output: Literal["html", "md"], + all_related_products: _Flag = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + asin: _Scalar = ..., + cert: _Cert = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + other_sellers: _Flag = ..., + proxies: _Proxies = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_product"], + all_related_products: _Flag = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + asin: _Scalar = ..., + cert: _Cert = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + other_sellers: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AmazonPromotionTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AmazonPromotionJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_promotion"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + include_products: _Flag = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + promotion_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["amazon_promotion"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + include_products: _Flag = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + promotion_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AppleAppStoreTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AppleAppStoreJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_app_store"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + country: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + disallow_explicit: _Flag = ..., + json_restrictor: _Scalar = ..., + lang: Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + property: Literal["developer"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_app_store"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + country: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + disallow_explicit: _Flag = ..., + json_restrictor: _Scalar = ..., + lang: Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + property: Literal["developer"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AppleMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AppleMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_maps"], + output: Literal["html", "md"], + api_key: str = ..., + center: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + location: str = ..., + multi_select_options: _Scalar = ..., + no_cache: _Flag = ..., + open_at: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort: Literal["default", "distance", "ratings"] = ..., + span: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + toggles: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_maps"], + api_key: str = ..., + center: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + location: str = ..., + multi_select_options: _Scalar = ..., + no_cache: _Flag = ..., + open_at: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort: Literal["default", "distance", "ratings"] = ..., + span: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + toggles: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AppleMapsPlacesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AppleMapsPlacesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_maps_places"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + muid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_maps_places"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + muid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AppleProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AppleProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["app"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_product"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["app"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AppleReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AppleReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + sort: Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["apple_reviews"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + sort: Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AutozoneTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AutozoneJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["autozone"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["autozone"], + api_key: str = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: AutozoneProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: AutozoneProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["autozone_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_token: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["autozone_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_token: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BaiduTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BaiduJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu"], + output: Literal["html", "md"], + api_key: str = ..., + bs: _Scalar = ..., + cert: _Cert = ..., + ct: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + f: _Scalar = ..., + gpc: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + oq: _Scalar = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + q5: _Scalar = ..., + q6: _Scalar = ..., + rn: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu"], + api_key: str = ..., + bs: _Scalar = ..., + cert: _Cert = ..., + ct: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + f: _Scalar = ..., + gpc: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + oq: _Scalar = ..., + output: Literal["json"] = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + q5: _Scalar = ..., + q6: _Scalar = ..., + rn: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BaiduMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BaiduMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu_maps"], + output: Literal["html", "md"], + api_key: str = ..., + c: _Number = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu_maps"], + api_key: str = ..., + c: _Number = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BaiduNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BaiduNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + ct: _Number = ..., + json_restrictor: _Scalar = ..., + medium: _Number = ..., + no_cache: _Flag = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rn: _Number = ..., + rtt: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["baidu_news"], + api_key: str = ..., + cert: _Cert = ..., + ct: _Number = ..., + json_restrictor: _Scalar = ..., + medium: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rn: _Number = ..., + rtt: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filters: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filters: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingCopilotTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingCopilotJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_copilot"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_copilot"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_images"], + output: Literal["html", "md"], + age: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + api_key: str = ..., + aspect: Literal["square", "wide", "tall"] = ..., + cc: str = ..., + cert: _Cert = ..., + color2: Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"] = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + face: Literal["face", "portrait"] = ..., + first: _Number = ..., + imagesize: Literal["small", "medium", "large", "wallpaper"] = ..., + json_restrictor: _Scalar = ..., + license: Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + photo: Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["strict", "moderate", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_images"], + age: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + api_key: str = ..., + aspect: Literal["square", "wide", "tall"] = ..., + cc: str = ..., + cert: _Cert = ..., + color2: Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"] = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + face: Literal["face", "portrait"] = ..., + first: _Number = ..., + imagesize: Literal["small", "medium", "large", "wallpaper"] = ..., + json_restrictor: _Scalar = ..., + license: Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + photo: Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["strict", "moderate", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_maps"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + count: _Number = ..., + cp: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_maps"], + api_key: str = ..., + cert: _Cert = ..., + count: _Number = ..., + cp: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_news"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + qft: Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""] = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_news"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + qft: Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""] = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingReverseImageTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingReverseImageJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_reverse_image"], + output: Literal["html", "md"], + api_key: str = ..., + cab: _Number = ..., + cal: _Number = ..., + car: _Number = ..., + cat: _Number = ..., + cert: _Cert = ..., + count: _Number = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_reverse_image"], + api_key: str = ..., + cab: _Number = ..., + cal: _Number = ..., + car: _Number = ..., + cat: _Number = ..., + cert: _Cert = ..., + count: _Number = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + efirst: _Number = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_shopping"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + efirst: _Number = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BingVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BingVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + date: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + length: Literal["short", "medium", "long"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + resolution: Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"] = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + source_site: Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["bing_videos"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + date: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + length: Literal["short", "medium", "long"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + resolution: Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"] = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + source_site: Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BookingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BookingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["booking"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + flex_window: _Number = ..., + free_cancellation: _Flag = ..., + hl: Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"] = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nflt: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + rooms: _Number = ..., + session_token: _Scalar = ..., + sort_by: Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["booking"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + flex_window: _Number = ..., + free_cancellation: _Flag = ..., + hl: Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"] = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nflt: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + rooms: _Number = ..., + session_token: _Scalar = ..., + sort_by: Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BraveTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BraveJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spellcheck: _Flag = ..., + stream: Optional[bool] = ..., + tf: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spellcheck: _Flag = ..., + stream: Optional[bool] = ..., + tf: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BraveAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BraveAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["off", "moderate", "strict"] = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + units_of_measurement: Literal["metric", "us"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["off", "moderate", "strict"] = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + units_of_measurement: Literal["metric", "us"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BraveImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BraveImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_images"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_images"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: BraveVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: BraveVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + date: Literal["past_day", "past_week", "past_month", "past_year"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["brave_videos"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + date: Literal["past_day", "past_week", "past_month", "past_year"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DoordashTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DoordashJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["doordash"], + output: Literal["html", "md"], + address: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + deals: _Flag = ..., + fastest: _Flag = ..., + json_restrictor: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pickup: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + store_type: Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["doordash"], + address: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + deals: _Flag = ..., + fastest: _Flag = ..., + json_restrictor: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pickup: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + store_type: Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckAiTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckAiJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duck_ai"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + model: Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"] = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duck_ai"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + model: Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckduckgoTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckduckgoJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + search_assist: _Flag = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + search_assist: _Flag = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckduckgoLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckduckgoLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_light"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_light"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckduckgoMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckduckgoMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_maps"], + output: Literal["html", "md"], + api_key: str = ..., + bbox: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + strict_bbox: _Number = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_maps"], + api_key: str = ..., + bbox: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + strict_bbox: _Number = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckduckgoNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckduckgoNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_news"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: DuckduckgoShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: DuckduckgoShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["duckduckgo_shopping"], + api_key: str = ..., + cert: _Cert = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: EbayTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: EbayJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay"], + output: Literal["html", "md"], + LH_ItemCondition: _Scalar = ..., + LH_PrefLoc: _Number = ..., + _blrs: _Flag = ..., + _dmd: _Number = ..., + _ipg: _Number = ..., + _nkw: _Scalar = ..., + _pgn: _Number = ..., + _salic: _Number = ..., + _sasl: _Scalar = ..., + _saslop: _Number = ..., + _sop: _Number = ..., + _stpos: _Scalar = ..., + _udhi: _Number = ..., + _udlo: _Number = ..., + api_key: str = ..., + buying_format: Literal["Auction", "BIN", "BO"] = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + popular_filters: _Scalar = ..., + proxies: _Proxies = ..., + show_only: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay"], + LH_ItemCondition: _Scalar = ..., + LH_PrefLoc: _Number = ..., + _blrs: _Flag = ..., + _dmd: _Number = ..., + _ipg: _Number = ..., + _nkw: _Scalar = ..., + _pgn: _Number = ..., + _salic: _Number = ..., + _sasl: _Scalar = ..., + _saslop: _Number = ..., + _sop: _Number = ..., + _stpos: _Scalar = ..., + _udhi: _Number = ..., + _udlo: _Number = ..., + api_key: str = ..., + buying_format: Literal["Auction", "BIN", "BO"] = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + popular_filters: _Scalar = ..., + proxies: _Proxies = ..., + show_only: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: EbayProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: EbayProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + lang: str = ..., + locale: str = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + shipping_country: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay_product"], + api_key: str = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + lang: str = ..., + locale: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + shipping_country: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: EbaySellerTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: EbaySellerJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay_seller"], + output: Literal["html", "md"], + LH_ItemCondition: _Scalar = ..., + _ipg: _Number = ..., + _pgn: _Number = ..., + _sop: _Number = ..., + api_key: str = ..., + buying_format: _Number = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + free_shipping: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + seller_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["user", "store"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["ebay_seller"], + LH_ItemCondition: _Scalar = ..., + _ipg: _Number = ..., + _pgn: _Number = ..., + _sop: _Number = ..., + api_key: str = ..., + buying_format: _Number = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + free_shipping: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + seller_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["user", "store"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: EventbriteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: EventbriteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["eventbrite"], + output: Literal["html", "md"], + api_key: str = ..., + category: Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"] = ..., + cert: _Cert = ..., + date: Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"] = ..., + end_date: _Scalar = ..., + event_type: Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"] = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + online: _Flag = ..., + page: _Number = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["date"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["eventbrite"], + api_key: str = ..., + category: Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"] = ..., + cert: _Cert = ..., + date: Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"] = ..., + end_date: _Scalar = ..., + event_type: Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"] = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + online: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["date"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: ExtractTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: ExtractJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["extract"], + output: Literal["html", "md"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["extract"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: FacebookMarketplaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: FacebookMarketplaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["facebook_marketplace"], + output: Literal["html", "md"], + api_key: str = ..., + availability: Literal["available", "sold"] = ..., + category: Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"] = ..., + cert: _Cert = ..., + condition: _Scalar = ..., + days_since_listed: _Number = ..., + delivery_method: Literal["local_pick_up", "shipping"] = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort_by: Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["facebook_marketplace"], + api_key: str = ..., + availability: Literal["available", "sold"] = ..., + category: Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"] = ..., + cert: _Cert = ..., + condition: _Scalar = ..., + days_since_listed: _Number = ..., + delivery_method: Literal["local_pick_up", "shipping"] = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort_by: Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: FacebookProfileTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: FacebookProfileJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["facebook_profile"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["facebook_profile"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: Flightradar24TextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: Flightradar24JsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["flightradar24"], + output: Literal["html", "md"], + aircraft_type: _Scalar = ..., + airline: _Scalar = ..., + airport: _Scalar = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + callsign: _Scalar = ..., + cert: _Cert = ..., + departure_id: _Scalar = ..., + flight_number: _Scalar = ..., + json_restrictor: _Scalar = ..., + map_bounds: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + registration: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["flightradar24"], + aircraft_type: _Scalar = ..., + airline: _Scalar = ..., + airport: _Scalar = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + callsign: _Scalar = ..., + cert: _Cert = ..., + departure_id: _Scalar = ..., + flight_number: _Scalar = ..., + json_restrictor: _Scalar = ..., + map_bounds: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + registration: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GlassdoorCompaniesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GlassdoorCompaniesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_companies"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_companies"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GlassdoorJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GlassdoorJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + date_posted: _Number = ..., + easy_apply: _Flag = ..., + employer_id: _Scalar = ..., + job_type: Literal["full_time", "part_time", "contract"] = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + max_salary: _Number = ..., + min_rating: _Number = ..., + min_salary: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + remote: _Flag = ..., + seniority_level: Literal["internship", "entry_level", "mid_senior_level", "director", "executive"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_jobs"], + api_key: str = ..., + cert: _Cert = ..., + date_posted: _Number = ..., + easy_apply: _Flag = ..., + employer_id: _Scalar = ..., + job_type: Literal["full_time", "part_time", "contract"] = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + max_salary: _Number = ..., + min_rating: _Number = ..., + min_salary: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + remote: _Flag = ..., + seniority_level: Literal["internship", "entry_level", "mid_senior_level", "director", "executive"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GlassdoorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GlassdoorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + current_employees: _Flag = ..., + employer_id: _Scalar = ..., + employment_status: _Scalar = ..., + job_title: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: Literal["en", "fr", "de", "es", "pt", "it", "nl"] = ..., + location: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["glassdoor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + current_employees: _Flag = ..., + employer_id: _Scalar = ..., + employment_status: _Scalar = ..., + job_title: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: Literal["en", "fr", "de", "es", "pt", "it", "nl"] = ..., + location: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAboutThisResultTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAboutThisResultJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_about_this_result"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ilps: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + req_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_about_this_result"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ilps: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + req_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAdsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAdsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAdsTransparencyCenterTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAdsTransparencyCenterJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads_transparency_center"], + output: Literal["html", "md"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_format: Literal["text", "image", "video"] = ..., + end_date: _Scalar = ..., + get_advertiser: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + platform: Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"] = ..., + political_ads: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads_transparency_center"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_format: Literal["text", "image", "video"] = ..., + end_date: _Scalar = ..., + get_advertiser: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + platform: Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"] = ..., + political_ads: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAdsTransparencyCenterAdDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAdsTransparencyCenterAdDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads_transparency_center_ad_details"], + output: Literal["html", "md"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ads_transparency_center_ad_details"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + region: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAiOverviewTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAiOverviewJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ai_overview"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_ai_overview"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + client: Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"] = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + client: Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"] = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleBooksTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleBooksJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_books"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + document_type: Literal["books", "magazines", "newspapers"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view: Literal["preview", "full"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_books"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + document_type: Literal["books", "magazines", "newspapers"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view: Literal["preview", "full"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleEventDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleEventDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_event_details"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + event_token: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nearby_places: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_results: _Flag = ..., + similar_events: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_event_details"], + api_key: str = ..., + cert: _Cert = ..., + event_token: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nearby_places: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_results: _Flag = ..., + similar_events: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleEventsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleEventsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_events"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_events"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFinanceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFinanceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + window: Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + window: Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFinanceAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFinanceAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFinanceMarketsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFinanceMarketsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance_markets"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + trend: Literal["indexes"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_finance_markets"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + trend: Literal["indexes"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFlightsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFlightsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + booking_token: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + deep_search: _Flag = ..., + departure_id: _Scalar = ..., + departure_token: _Scalar = ..., + emissions: _Number = ..., + exclude_airlines: _Scalar = ..., + exclude_basic: _Flag = ..., + exclude_conns: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + layover_duration: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + multi_city_json: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + outbound_times: _Scalar = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + return_times: _Scalar = ..., + selected_flights_json: _Scalar = ..., + show_hidden: _Flag = ..., + sort_by: _Number = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + booking_token: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + deep_search: _Flag = ..., + departure_id: _Scalar = ..., + departure_token: _Scalar = ..., + emissions: _Number = ..., + exclude_airlines: _Scalar = ..., + exclude_basic: _Flag = ..., + exclude_conns: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + layover_duration: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + multi_city_json: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + outbound_times: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + return_times: _Scalar = ..., + selected_flights_json: _Scalar = ..., + show_hidden: _Flag = ..., + sort_by: _Number = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFlightsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFlightsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + exclude_regions: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + exclude_regions: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFlightsCalendarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFlightsCalendarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_calendar"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + date_range_end: _Scalar = ..., + date_range_start: _Scalar = ..., + departure_id: _Scalar = ..., + fixed_outbound_date: _Flag = ..., + gl: str = ..., + hl: str = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + round_trip_days: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_calendar"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + date_range_end: _Scalar = ..., + date_range_start: _Scalar = ..., + departure_id: _Scalar = ..., + fixed_outbound_date: _Flag = ..., + gl: str = ..., + hl: str = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + round_trip_days: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleFlightsDealsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleFlightsDealsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_deals"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + trip_length: _Scalar = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_flights_deals"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + trip_length: _Scalar = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleForumsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleForumsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_forums"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_forums"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleGeminiTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleGeminiJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_gemini"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_gemini"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleHotelsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleHotelsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels"], + output: Literal["html", "md"], + adults: _Number = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + brands: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + eco_certified: _Flag = ..., + free_cancellation: _Flag = ..., + gl: str = ..., + hl: str = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: _Number = ..., + special_offers: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vacation_rentals: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels"], + adults: _Number = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + brands: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + eco_certified: _Flag = ..., + free_cancellation: _Flag = ..., + gl: str = ..., + hl: str = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: _Number = ..., + special_offers: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vacation_rentals: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleHotelsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleHotelsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleHotelsPhotosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleHotelsPhotosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_photos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_photos"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleHotelsPriceCalendarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleHotelsPriceCalendarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_price_calendar"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_price_calendar"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleHotelsReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleHotelsReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + category_token: _Scalar = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + sort_by: _Number = ..., + source_number: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_hotels_reviews"], + api_key: str = ..., + category_token: _Scalar = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + sort_by: _Number = ..., + source_number: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ijn: _Number = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ijn: _Number = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleImagesLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleImagesLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleImagesRelatedContentTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleImagesRelatedContentJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images_related_content"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + related_content_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_images_related_content"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + related_content_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleImmersiveProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleImmersiveProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_immersive_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + more_stores: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_immersive_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + more_stores: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lrad: _Number = ..., + ltype: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_jobs"], + api_key: str = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lrad: _Number = ..., + ltype: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleJobsListingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleJobsListingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_jobs_listing"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_jobs_listing"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleLensTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleLensJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_lens"], + output: Literal["html", "md"], + api_key: str = ..., + auto_crop: _Flag = ..., + cert: _Cert = ..., + country: str = ..., + hl: str = ..., + image_id: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["all", "exact_matches", "visual_matches"] = ..., + url: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_lens"], + api_key: str = ..., + auto_crop: _Flag = ..., + cert: _Cert = ..., + country: str = ..., + hl: str = ..., + image_id: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["all", "exact_matches", "visual_matches"] = ..., + url: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleLocalTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleLocalJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_local"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + ludocid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_local"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + ludocid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleLocalServicesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleLocalServicesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_local_services"], + output: Literal["html", "md"], + api_key: str = ..., + bid: _Number = ..., + cert: _Cert = ..., + cid: _Number = ..., + data_cid: _Number = ..., + hl: str = ..., + job_type: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + pid: _Number = ..., + proxies: _Proxies = ..., + q: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_local_services"], + api_key: str = ..., + bid: _Number = ..., + cert: _Cert = ..., + cid: _Number = ..., + data_cid: _Number = ..., + hl: str = ..., + job_type: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pid: _Number = ..., + proxies: _Proxies = ..., + q: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data: _Scalar = ..., + data_cid: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + ll: _Scalar = ..., + location: str = ..., + lon: _Number = ..., + m: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + min_rating: _Number = ..., + nearby: _Flag = ..., + no_cache: _Flag = ..., + open_at_hour: _Number = ..., + open_on_day: Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"] = ..., + open_state: Literal["now", "24h"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["search", "place"] = ..., + verify: _Verify = ..., + z: _Number = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps"], + api_key: str = ..., + cert: _Cert = ..., + data: _Scalar = ..., + data_cid: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + ll: _Scalar = ..., + location: str = ..., + lon: _Number = ..., + m: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + min_rating: _Number = ..., + nearby: _Flag = ..., + no_cache: _Flag = ..., + open_at_hour: _Number = ..., + open_on_day: Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"] = ..., + open_state: Literal["now", "24h"] = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["search", "place"] = ..., + verify: _Verify = ..., + z: _Number = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsContributorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsContributorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_contributor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + contributor_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_contributor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + contributor_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsDirectionsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsDirectionsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_directions"], + output: Literal["html", "md"], + api_key: str = ..., + avoid: _Scalar = ..., + cert: _Cert = ..., + distance_unit: _Number = ..., + end_addr: _Scalar = ..., + end_coords: _Scalar = ..., + end_data_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + prefer: _Scalar = ..., + proxies: _Proxies = ..., + route: _Number = ..., + start_addr: _Scalar = ..., + start_coords: _Scalar = ..., + start_data_id: _Scalar = ..., + stream: Optional[bool] = ..., + time: _Scalar = ..., + timeout: _Timeout = ..., + travel_mode: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_directions"], + api_key: str = ..., + avoid: _Scalar = ..., + cert: _Cert = ..., + distance_unit: _Number = ..., + end_addr: _Scalar = ..., + end_coords: _Scalar = ..., + end_data_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefer: _Scalar = ..., + proxies: _Proxies = ..., + route: _Number = ..., + start_addr: _Scalar = ..., + start_coords: _Scalar = ..., + start_data_id: _Scalar = ..., + stream: Optional[bool] = ..., + time: _Scalar = ..., + timeout: _Timeout = ..., + travel_mode: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsPhotoMetaTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsPhotoMetaJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_photo_meta"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_photo_meta"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsPhotosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsPhotosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_photos"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_photos"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsPostsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsPostsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_posts"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_posts"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleMapsReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleMapsReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_id: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_maps_reviews"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_id: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + publication_token: _Scalar = ..., + q: _Scalar = ..., + section_token: _Scalar = ..., + so: _Number = ..., + story_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_token: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_news"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + publication_token: _Scalar = ..., + q: _Scalar = ..., + section_token: _Scalar = ..., + so: _Number = ..., + story_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_token: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleNewsLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleNewsLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_news_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_news_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePatentsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePatentsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_patents"], + output: Literal["html", "md"], + after: _Scalar = ..., + api_key: str = ..., + assignee: _Scalar = ..., + before: _Scalar = ..., + cert: _Cert = ..., + clustered: Literal["true"] = ..., + country: _Scalar = ..., + dups: Literal["language"] = ..., + inventor: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: _Scalar = ..., + litigation: Literal["YES", "NO"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + patents: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + scholar: _Flag = ..., + sort: Literal["new", "old"] = ..., + status: Literal["GRANT", "APPLICATION"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["PATENT", "DESIGN"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_patents"], + after: _Scalar = ..., + api_key: str = ..., + assignee: _Scalar = ..., + before: _Scalar = ..., + cert: _Cert = ..., + clustered: Literal["true"] = ..., + country: _Scalar = ..., + dups: Literal["language"] = ..., + inventor: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: _Scalar = ..., + litigation: Literal["YES", "NO"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + patents: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + scholar: _Flag = ..., + sort: Literal["new", "old"] = ..., + status: Literal["GRANT", "APPLICATION"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["PATENT", "DESIGN"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePatentsDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePatentsDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_patents_details"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + patent_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_patents_details"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + patent_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePlayTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePlayJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + apps_category: Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"] = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "tablet", "tv", "chromebook", "watch", "car"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + apps_category: Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"] = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "tablet", "tv", "chromebook", "watch", "car"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePlayBooksTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePlayBooksJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_books"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + books_category: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + price: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_books"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + books_category: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + price: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePlayGamesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePlayGamesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_games"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + games_category: Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_games"], + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + games_category: Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePlayMoviesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePlayMoviesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_movies"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + movies_category: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_movies"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + movies_category: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GooglePlayProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GooglePlayProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_product"], + output: Literal["html", "md"], + all_reviews: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + platform: Literal["phone", "tablet", "watch", "chromebook", "tv", "car"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + season_id: _Scalar = ..., + sort_by: _Number = ..., + store: Literal["apps", "movies", "tv", "books", "audiobooks"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_play_product"], + all_reviews: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + platform: Literal["phone", "tablet", "watch", "chromebook", "tv", "car"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + season_id: _Scalar = ..., + sort_by: _Number = ..., + store: Literal["apps", "movies", "tv", "books", "audiobooks"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + offer_view: _Flag = ..., + page_token: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_product"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + offer_view: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleRelatedQuestionsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleRelatedQuestionsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_related_questions"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_related_questions"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleReverseImageTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleReverseImageJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_reverse_image"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_reverse_image"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleScholarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleScholarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar"], + output: Literal["html", "md"], + api_key: str = ..., + as_rr: _Flag = ..., + as_sdt: _Scalar = ..., + as_vis: _Flag = ..., + as_yhi: _Number = ..., + as_ylo: _Number = ..., + cert: _Cert = ..., + cites: _Scalar = ..., + cluster: _Scalar = ..., + filter: _Flag = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + scisbd: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar"], + api_key: str = ..., + as_rr: _Flag = ..., + as_sdt: _Scalar = ..., + as_vis: _Flag = ..., + as_yhi: _Number = ..., + as_ylo: _Number = ..., + cert: _Cert = ..., + cites: _Scalar = ..., + cluster: _Scalar = ..., + filter: _Flag = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + scisbd: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleScholarAuthorTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleScholarAuthorJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_author"], + output: Literal["html", "md"], + api_key: str = ..., + author_id: _Scalar = ..., + cert: _Cert = ..., + citation_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["title", "pubdate"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view_op: Literal["view_citation", "list_colleagues"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_author"], + api_key: str = ..., + author_id: _Scalar = ..., + cert: _Cert = ..., + citation_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + sort: Literal["title", "pubdate"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view_op: Literal["view_citation", "list_colleagues"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleScholarCaseLawTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleScholarCaseLawJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_case_law"], + output: Literal["html", "md"], + api_key: str = ..., + case_id: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_case_law"], + api_key: str = ..., + case_id: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleScholarCiteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleScholarCiteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_cite"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_scholar_cite"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleShoppingFiltersTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleShoppingFiltersJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping_filters"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + shoprs: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping_filters"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + shoprs: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleShoppingLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleShoppingLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping_light"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_shopping_light"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleShortVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleShortVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_short_videos"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_short_videos"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleSportsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleSportsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_sports"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + moa: _Scalar = ..., + mob: _Scalar = ..., + mpd: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + season_kgmid: _Scalar = ..., + sp: Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"] = ..., + stream: Optional[bool] = ..., + tab: Literal["gm", "sn", "pl", "br", "st", "rn", "ov"] = ..., + timeout: _Timeout = ..., + type: Literal["game", "league", "team"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_sports"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + moa: _Scalar = ..., + mob: _Scalar = ..., + mpd: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + season_kgmid: _Scalar = ..., + sp: Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"] = ..., + stream: Optional[bool] = ..., + tab: Literal["gm", "sn", "pl", "br", "st", "rn", "ov"] = ..., + timeout: _Timeout = ..., + type: Literal["game", "league", "team"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTranslateTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTranslateJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_translate"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + to: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_translate"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + to: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTravelExploreTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTravelExploreJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_travel_explore"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_area_id: _Scalar = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + interest: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + travel_mode: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_travel_explore"], + adults: _Number = ..., + api_key: str = ..., + arrival_area_id: _Scalar = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + interest: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + travel_mode: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTrendsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTrendsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends"], + output: Literal["html", "md"], + api_key: str = ..., + cat: _Number = ..., + cert: _Cert = ..., + csv: _Flag = ..., + data_type: Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"] = ..., + date: _Scalar = ..., + geo: _Scalar = ..., + gprop: Literal["", "images", "news", "froogle", "youtube"] = ..., + hl: str = ..., + include_low_search_volume: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + region: Literal["COUNTRY", "REGION", "DMA", "CITY"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tz: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends"], + api_key: str = ..., + cat: _Number = ..., + cert: _Cert = ..., + csv: _Flag = ..., + data_type: Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"] = ..., + date: _Scalar = ..., + geo: _Scalar = ..., + gprop: Literal["", "images", "news", "froogle", "youtube"] = ..., + hl: str = ..., + include_low_search_volume: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + region: Literal["COUNTRY", "REGION", "DMA", "CITY"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tz: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTrendsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTrendsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTrendsNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTrendsNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_news"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleTrendsTrendingNowTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleTrendsTrendingNowJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_trending_now"], + output: Literal["html", "md"], + api_key: str = ..., + cat: Literal["all", "b", "e", "m", "t", "s", "h"] = ..., + category_id: _Number = ..., + cert: _Cert = ..., + date: _Scalar = ..., + frequency: Literal["daily", "realtime"] = ..., + geo: _Number = ..., + hl: str = ..., + hours: _Number = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + only_active: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_trends_trending_now"], + api_key: str = ..., + cat: Literal["all", "b", "e", "m", "t", "s", "h"] = ..., + category_id: _Number = ..., + cert: _Cert = ..., + date: _Scalar = ..., + frequency: Literal["daily", "realtime"] = ..., + geo: _Number = ..., + hl: str = ..., + hours: _Number = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + only_active: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_videos"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_videos"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: GoogleVideosLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: GoogleVideosLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_videos_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["google_videos_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: HomeDepotTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: HomeDepotJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["us", "ca"] = ..., + delivery_zip: _Scalar = ..., + filter: _Scalar = ..., + hd_filter_tokens: _Scalar = ..., + hd_sort: Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"] = ..., + json_restrictor: _Scalar = ..., + lowerbound: _Number = ..., + minmax: _Scalar = ..., + nao: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pagesize: _Scalar = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"] = ..., + store: _Scalar = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + upperbound: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["us", "ca"] = ..., + delivery_zip: _Scalar = ..., + filter: _Scalar = ..., + hd_filter_tokens: _Scalar = ..., + hd_sort: Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"] = ..., + json_restrictor: _Scalar = ..., + lowerbound: _Number = ..., + minmax: _Scalar = ..., + nao: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pagesize: _Scalar = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"] = ..., + store: _Scalar = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + upperbound: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: HomeDepotProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: HomeDepotProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + store_sku: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot_product"], + api_key: str = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + store_sku: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: HomeDepotProductReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: HomeDepotProductReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot_product_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + pagesize: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verified_purchases: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["home_depot_product_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pagesize: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verified_purchases: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: IndeedJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: IndeedJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["indeed_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + fromage: _Number = ..., + json_restrictor: _Scalar = ..., + jt: Literal["fulltime", "parttime", "contract", "temporary", "internship"] = ..., + l: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort: Literal["date"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["indeed_jobs"], + api_key: str = ..., + cert: _Cert = ..., + fromage: _Number = ..., + json_restrictor: _Scalar = ..., + jt: Literal["fulltime", "parttime", "contract", "temporary", "internship"] = ..., + l: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort: Literal["date"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: InstagramPopularTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: InstagramPopularJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["instagram_popular"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + keyword: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["instagram_popular"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + keyword: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: InstagramProfileTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: InstagramProfileJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["instagram_profile"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["instagram_profile"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: MetaAdLibraryTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: MetaAdLibraryJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["meta_ad_library"], + output: Literal["html", "md"], + active_status: Literal["active", "inactive", "all"] = ..., + ad_type: Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"] = ..., + api_key: str = ..., + cert: _Cert = ..., + content_languages: _Scalar = ..., + country: str = ..., + end_date: _Scalar = ..., + json_restrictor: _Scalar = ..., + media_type: Literal["all", "image", "meme", "image_and_meme", "video", "none"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + page_id: _Scalar = ..., + proxies: _Proxies = ..., + publisher_platforms: _Scalar = ..., + q: _Scalar = ..., + search_type: Literal["keyword_unordered", "keyword_exact_phrase"] = ..., + sort_by: Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["meta_ad_library"], + active_status: Literal["active", "inactive", "all"] = ..., + ad_type: Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"] = ..., + api_key: str = ..., + cert: _Cert = ..., + content_languages: _Scalar = ..., + country: str = ..., + end_date: _Scalar = ..., + json_restrictor: _Scalar = ..., + media_type: Literal["all", "image", "meme", "image_and_meme", "video", "none"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_id: _Scalar = ..., + proxies: _Proxies = ..., + publisher_platforms: _Scalar = ..., + q: _Scalar = ..., + search_type: Literal["keyword_unordered", "keyword_exact_phrase"] = ..., + sort_by: Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: NapaTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: NapaJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["napa"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["napa"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: NaverTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: NaverJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + period: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + where: Literal["nexearch", "web", "news", "video", "image"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + period: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + where: Literal["nexearch", "web", "news", "video", "image"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: NaverAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: NaverAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: NaverAiOverviewTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: NaverAiOverviewJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_ai_overview"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_ai_overview"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: NaverMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: NaverMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_maps"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + bookable: _Flag = ..., + center: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + coupon: _Flag = ..., + json_restrictor: _Scalar = ..., + naver_pay: _Flag = ..., + no_cache: _Flag = ..., + open_state: Literal["now"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + wheelchair_accessible: _Flag = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["naver_maps"], + adults: _Number = ..., + api_key: str = ..., + bookable: _Flag = ..., + center: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + coupon: _Flag = ..., + json_restrictor: _Scalar = ..., + naver_pay: _Flag = ..., + no_cache: _Flag = ..., + open_state: Literal["now"] = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + wheelchair_accessible: _Flag = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: OpenTableReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: OpenTableReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["open_table_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + open_table_domain: Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rid: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["open_table_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + open_table_domain: Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"] = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rid: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: PinterestTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: PinterestJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["pinterest"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + less_ai: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["pins", "videos", "boards", "profiles", "products"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["pinterest"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + less_ai: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["pins", "videos", "boards", "profiles", "products"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: SearchIndexTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: SearchIndexJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["search_index"], + output: Literal["html", "md"], + api_key: str = ..., + as_yhi: _Scalar = ..., + as_ylo: _Scalar = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + mode: Literal["deep"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + product_source: Literal["google", "amazon", "walmart", "ebay", "home_depot"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["web", "place", "product", "video", "publication"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["search_index"], + api_key: str = ..., + as_yhi: _Scalar = ..., + as_ylo: _Scalar = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + mode: Literal["deep"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + product_source: Literal["google", "amazon", "walmart", "ebay", "home_depot"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["web", "place", "product", "video", "publication"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TargetTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TargetJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["target"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["target"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TiktokDiscoverTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TiktokDiscoverJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tiktok_discover"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + session_token: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tiktok_discover"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + session_token: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TiktokShopTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TiktokShopJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tiktok_shop"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + color_id: _Scalar = ..., + deals: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort: Literal["relevance", "best_seller", "newest"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tiktok_shop"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + color_id: _Scalar = ..., + deals: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort: Literal["relevance", "best_seller", "newest"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TraderJoesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TraderJoesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["trader_joes"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + characteristics: _Scalar = ..., + json_restrictor: _Scalar = ..., + new_products: _Flag = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["price_low_to_high", "price_high_to_low", "popularity"] = ..., + store_id: _Number = ..., + stream: Optional[bool] = ..., + tags: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["trader_joes"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + characteristics: _Scalar = ..., + json_restrictor: _Scalar = ..., + new_products: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["price_low_to_high", "price_high_to_low", "popularity"] = ..., + store_id: _Number = ..., + stream: Optional[bool] = ..., + tags: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TraderJoesProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TraderJoesProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["trader_joes_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["trader_joes_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TripadvisorTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TripadvisorJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + limit: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + ssrc: Literal["a", "r", "A", "h", "g", "v", "f"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + limit: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + ssrc: Literal["a", "r", "A", "h", "g", "v", "f"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TripadvisorPlaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TripadvisorPlaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor_place"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor_place"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: TripadvisorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: TripadvisorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language: Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"] = ..., + limit: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["most_recent", "detailed_review"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + type_of_visit: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["tripadvisor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language: Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"] = ..., + limit: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["most_recent", "detailed_review"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + type_of_visit: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: WalmartTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: WalmartJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart"], + output: Literal["html", "md"], + api_key: str = ..., + cat_id: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nd_en: _Flag = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + soft_sort: _Flag = ..., + sort: Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + walmart_domain: Literal["walmart.com", "walmart.com.mx"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart"], + api_key: str = ..., + cat_id: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nd_en: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + soft_sort: _Flag = ..., + sort: Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + walmart_domain: Literal["walmart.com", "walmart.com.mx"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: WalmartProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: WalmartProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: WalmartProductReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: WalmartProductReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + sort: Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + sort: Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: WalmartProductSellersTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: WalmartProductSellersJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product_sellers"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_product_sellers"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: WalmartSellerTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: WalmartSellerJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_seller"], + output: Literal["html", "md"], + api_key: str = ..., + catalog_seller_id: _Scalar = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["walmart_seller"], + api_key: str = ..., + catalog_seller_id: _Scalar = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YahooTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YahooJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + d: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + fr2: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vc: str = ..., + verify: _Verify = ..., + vf: Literal["html", "pdf", "xls", "ppt", "doc", "txt"] = ..., + vl: Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"] = ..., + vm: Literal["r", "i", "p"] = ..., + vs: _Scalar = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + d: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + fr2: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vc: str = ..., + verify: _Verify = ..., + vf: Literal["html", "pdf", "xls", "ppt", "doc", "txt"] = ..., + vl: Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"] = ..., + vm: Literal["r", "i", "p"] = ..., + vs: _Scalar = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YahooImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YahooImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_images"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + imga: Literal["square", "wide", "tall"] = ..., + imgc: Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"] = ..., + imgf: Literal["face", "portrait", "nonportrait"] = ..., + imgl: Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"] = ..., + imgsz: Literal["small", "medium", "large", "wallpaper"] = ..., + imgt: Literal["day", "week", "month", "year"] = ..., + imgty: Literal["photo", "clipart", "linedrawing", "gif", "transparent"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yahoo_domain: Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_images"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + imga: Literal["square", "wide", "tall"] = ..., + imgc: Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"] = ..., + imgf: Literal["face", "portrait", "nonportrait"] = ..., + imgl: Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"] = ..., + imgsz: Literal["small", "medium", "large", "wallpaper"] = ..., + imgt: Literal["day", "week", "month", "year"] = ..., + imgty: Literal["photo", "clipart", "linedrawing", "gif", "transparent"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yahoo_domain: Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YahooShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YahooShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + category_attr_values: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Scalar = ..., + merchants: _Scalar = ..., + min_price: _Scalar = ..., + no_cache: _Flag = ..., + order_by: Literal["ASC", "DESC"] = ..., + p: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort_by: Literal["price", "relevancy", "popularity", "discountPercentage"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_shopping"], + api_key: str = ..., + category_attr_values: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Scalar = ..., + merchants: _Scalar = ..., + min_price: _Scalar = ..., + no_cache: _Flag = ..., + order_by: Literal["ASC", "DESC"] = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort_by: Literal["price", "relevancy", "popularity", "discountPercentage"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YahooTrendsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YahooTrendsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_trends"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + full_video_links: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_trends"], + api_key: str = ..., + cert: _Cert = ..., + full_video_links: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YahooVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YahooVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_videos"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + durs: Literal["short", "medium", "long"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vage: Literal["day", "week", "month", "year"] = ..., + verify: _Verify = ..., + vres: Literal["360p", "480p", "720p", "1080p"] = ..., + vsite: Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"] = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yahoo_videos"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + durs: Literal["short", "medium", "long"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vage: Literal["day", "week", "month", "year"] = ..., + verify: _Verify = ..., + vres: Literal["360p", "480p", "720p", "1080p"] = ..., + vsite: Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"] = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YandexTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YandexJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + family_mode: _Number = ..., + fix_typo: Literal["false", "true"] = ..., + groups_on_page: _Number = ..., + json_restrictor: _Scalar = ..., + lang: Literal["ru", "en", "be", "kk", "tr", "uk"] = ..., + lr: _Number = ..., + no_cache: _Flag = ..., + p: _Number = ..., + period: Literal["all", "day", "last_two_weeks", "month"] = ..., + proxies: _Proxies = ..., + sort_mode: Literal["relevance", "time"] = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex"], + api_key: str = ..., + cert: _Cert = ..., + family_mode: _Number = ..., + fix_typo: Literal["false", "true"] = ..., + groups_on_page: _Number = ..., + json_restrictor: _Scalar = ..., + lang: Literal["ru", "en", "be", "kk", "tr", "uk"] = ..., + lr: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Number = ..., + period: Literal["all", "day", "last_two_weeks", "month"] = ..., + proxies: _Proxies = ..., + sort_mode: Literal["relevance", "time"] = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YandexImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YandexImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex_images"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + color: Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"] = ..., + crop: _Scalar = ..., + crop_id: _Number = ..., + family_mode: _Number = ..., + file_type: Literal["jpg", "png", "gifan"] = ..., + height: _Number = ..., + image_type: Literal["photo", "clipart", "lineart", "face", "demotivator"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + orientation: Literal["horizontal", "vertical", "square"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + recent: _Flag = ..., + site: _Scalar = ..., + stream: Optional[bool] = ..., + tab: Literal["about", "similar"] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + url: _Scalar = ..., + verify: _Verify = ..., + width: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex_images"], + api_key: str = ..., + cert: _Cert = ..., + color: Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"] = ..., + crop: _Scalar = ..., + crop_id: _Number = ..., + family_mode: _Number = ..., + file_type: Literal["jpg", "png", "gifan"] = ..., + height: _Number = ..., + image_type: Literal["photo", "clipart", "lineart", "face", "demotivator"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + orientation: Literal["horizontal", "vertical", "square"] = ..., + output: Literal["json"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + recent: _Flag = ..., + site: _Scalar = ..., + stream: Optional[bool] = ..., + tab: Literal["about", "similar"] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + url: _Scalar = ..., + verify: _Verify = ..., + width: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YandexVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YandexVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + duration: Literal["short", "medium", "long"] = ..., + hd: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + within: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yandex_videos"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + duration: Literal["short", "medium", "long"] = ..., + hd: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + within: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YelpTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YelpJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + find_desc: _Scalar = ..., + find_loc: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + sortby: Literal["recommended", "rating", "review_count"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp"], + api_key: str = ..., + cert: _Cert = ..., + find_desc: _Scalar = ..., + find_loc: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + sortby: Literal["recommended", "rating", "review_count"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YelpPlaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YelpPlaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp_place"], + output: Literal["html", "md"], + api_key: str = ..., + business_alert: _Flag = ..., + cert: _Cert = ..., + full_menu: _Flag = ..., + json_restrictor: _Scalar = ..., + menu_name: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp_place"], + api_key: str = ..., + business_alert: _Flag = ..., + cert: _Cert = ..., + full_menu: _Flag = ..., + json_restrictor: _Scalar = ..., + menu_name: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YelpReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YelpReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + not_recommended: _Flag = ..., + not_recommended_start: _Number = ..., + num: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Scalar = ..., + sortby: Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["yelp_reviews"], + api_key: str = ..., + cert: _Cert = ..., + hl: Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + not_recommended: _Flag = ..., + not_recommended_start: _Number = ..., + num: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Scalar = ..., + sortby: Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YoutubeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YoutubeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sp: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sp: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YoutubeChannelTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YoutubeChannelJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_channel"], + output: Literal["html", "md"], + about: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + channel_id: _Scalar = ..., + gl: str = ..., + hl: Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"] = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sort: Literal["latest", "popular", "oldest", "dd", "lad"] = ..., + stream: Optional[bool] = ..., + tab: Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_channel"], + about: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + channel_id: _Scalar = ..., + gl: str = ..., + hl: Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"] = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sort: Literal["latest", "popular", "oldest", "dd", "lad"] = ..., + stream: Optional[bool] = ..., + tab: Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YoutubeVideoTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YoutubeVideoJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_video"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_video"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: YoutubeVideoTranscriptTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: YoutubeVideoTranscriptJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_video_transcript"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language_code: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + title: _Scalar = ..., + type: Literal["asr"] = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["youtube_video_transcript"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language_code: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + title: _Scalar = ..., + type: Literal["asr"] = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: ZillowTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search( + self, + params: ZillowJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["zillow"], + output: Literal["html", "md"], + age_55_plus: Literal["include", "exclude", "only"] = ..., + amenities: _Scalar = ..., + api_key: str = ..., + basement: _Scalar = ..., + baths: _Scalar = ..., + beds: _Scalar = ..., + cert: _Cert = ..., + has_garage: _Flag = ..., + hide_no_date_listings: _Flag = ..., + hoa_max: _Number = ..., + home_type: _Scalar = ..., + json_restrictor: _Scalar = ..., + keywords: _Scalar = ..., + listing_features: _Scalar = ..., + listing_status: _Scalar = ..., + listing_type: _Scalar = ..., + lot_size: _Scalar = ..., + map_bounds: _Scalar = ..., + move_in_date: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + parking_spots: _Number = ..., + pets: _Scalar = ..., + price: _Scalar = ..., + price_reduction: _Flag = ..., + proxies: _Proxies = ..., + region_id: _Scalar = ..., + short_term_lease: _Flag = ..., + single_story: _Flag = ..., + sort_by: Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"] = ..., + space: Literal["any", "entire_place", "room"] = ..., + sqft: _Scalar = ..., + status_type: Literal["sale", "rent", "sold"] = ..., + stream: Optional[bool] = ..., + time_on_zillow: _Scalar = ..., + timeout: _Timeout = ..., + tours: _Scalar = ..., + verify: _Verify = ..., + view: _Scalar = ..., + year_built: _Scalar = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def search( + self, + params: None = None, + *, + engine: Literal["zillow"], + age_55_plus: Literal["include", "exclude", "only"] = ..., + amenities: _Scalar = ..., + api_key: str = ..., + basement: _Scalar = ..., + baths: _Scalar = ..., + beds: _Scalar = ..., + cert: _Cert = ..., + has_garage: _Flag = ..., + hide_no_date_listings: _Flag = ..., + hoa_max: _Number = ..., + home_type: _Scalar = ..., + json_restrictor: _Scalar = ..., + keywords: _Scalar = ..., + listing_features: _Scalar = ..., + listing_status: _Scalar = ..., + listing_type: _Scalar = ..., + lot_size: _Scalar = ..., + map_bounds: _Scalar = ..., + move_in_date: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + parking_spots: _Number = ..., + pets: _Scalar = ..., + price: _Scalar = ..., + price_reduction: _Flag = ..., + proxies: _Proxies = ..., + region_id: _Scalar = ..., + short_term_lease: _Flag = ..., + single_story: _Flag = ..., + sort_by: Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"] = ..., + space: Literal["any", "entire_place", "room"] = ..., + sqft: _Scalar = ..., + status_type: Literal["sale", "rent", "sold"] = ..., + stream: Optional[bool] = ..., + time_on_zillow: _Scalar = ..., + timeout: _Timeout = ..., + tours: _Scalar = ..., + verify: _Verify = ..., + view: _Scalar = ..., + year_built: _Scalar = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def search( + self, + params: Union[SearchParams, MutableMapping[str, Any]], + **kwargs: Any, + ) -> Union[SerpResults, Any]: ... + @overload + def extract( + self, + params: ExtractTextParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def extract( + self, + params: ExtractJsonParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def extract( + self, + params: None = None, + *, + output: Literal["html", "md"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> str: ... + @overload + def extract( + self, + params: None = None, + *, + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., + ) -> SerpResults: ... + @overload + def extract( + self, + params: Mapping[str, Any], + **kwargs: Any, + ) -> Union[SerpResults, Any]: ... + @overload + def search_archive( + self, + params: SearchArchiveTextParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search_archive( + self, + params: SearchArchiveJsonParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search_archive( + self, + params: None = None, + *, + output: Literal["html", "md"], + search_id: str, + api_key: str = ..., + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> str: ... + @overload + def search_archive( + self, + params: None = None, + *, + search_id: str, + api_key: str = ..., + cert: _Cert = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + ) -> SerpResults: ... + @overload + def search_archive( + self, + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + **kwargs: Any, + ) -> Union[SerpResults, Any]: ... + def upload_image(self, image: Union[str, PathLike[str], IO[bytes]], *, cert: _Cert = ..., proxies: _Proxies = ..., stream: Optional[bool] = ..., timeout: _Timeout = ..., verify: _Verify = ..., **kwargs: Any) -> Dict[str, Any]: ... + def locations(self, params: Optional[MutableMapping[str, Any]] = None, **kwargs: Any) -> List[Dict[str, Any]]: ... + def account(self, params: Optional[MutableMapping[str, Any]] = None, **kwargs: Any) -> Dict[str, Any]: ... + +@overload +def search( + params: AirbnbTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AirbnbJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["airbnb"], + output: Literal["html", "md"], + accessibility_features: _Scalar = ..., + adults: _Number = ..., + airbnb_domain: str = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + beds: _Number = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + currency: Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"] = ..., + guest_favorite: _Flag = ..., + host_languages: _Scalar = ..., + infants: _Number = ..., + instant_book: _Flag = ..., + json_restrictor: _Scalar = ..., + luxe: _Flag = ..., + map_bounds: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pets: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + room_type: Literal["entire_home", "private_room"] = ..., + self_check_in: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["airbnb"], + accessibility_features: _Scalar = ..., + adults: _Number = ..., + airbnb_domain: str = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + beds: _Number = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + currency: Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"] = ..., + guest_favorite: _Flag = ..., + host_languages: _Scalar = ..., + infants: _Number = ..., + instant_book: _Flag = ..., + json_restrictor: _Scalar = ..., + luxe: _Flag = ..., + map_bounds: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pets: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + room_type: Literal["entire_home", "private_room"] = ..., + self_check_in: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AmazonTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AmazonJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + emi: _Scalar = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + emi: _Scalar = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AmazonAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AmazonAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_autocomplete"], + output: Literal["html", "md"], + amazon_department: Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"] = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_autocomplete"], + amazon_department: Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"] = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AmazonFreshTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AmazonFreshJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_fresh"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_fresh"], + amazon_domain: Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"] = ..., + api_key: str = ..., + cert: _Cert = ..., + dc: _Flag = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + k: _Scalar = ..., + language: Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"] = ..., + no_cache: _Flag = ..., + node: _Scalar = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rh: _Scalar = ..., + s: Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AmazonProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AmazonProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_product"], + output: Literal["html", "md"], + all_related_products: _Flag = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + asin: _Scalar = ..., + cert: _Cert = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + other_sellers: _Flag = ..., + proxies: _Proxies = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_product"], + all_related_products: _Flag = ..., + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + asin: _Scalar = ..., + cert: _Cert = ..., + delivery_city: _Scalar = ..., + delivery_zip: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + other_sellers: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + shipping_location: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AmazonPromotionTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AmazonPromotionJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_promotion"], + output: Literal["html", "md"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + include_products: _Flag = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + promotion_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["amazon_promotion"], + amazon_domain: Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"] = ..., + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + include_products: _Flag = ..., + json_restrictor: _Scalar = ..., + language: Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + promotion_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AppleAppStoreTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AppleAppStoreJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_app_store"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + country: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + disallow_explicit: _Flag = ..., + json_restrictor: _Scalar = ..., + lang: Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + property: Literal["developer"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_app_store"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + country: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + disallow_explicit: _Flag = ..., + json_restrictor: _Scalar = ..., + lang: Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + property: Literal["developer"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AppleMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AppleMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_maps"], + output: Literal["html", "md"], + api_key: str = ..., + center: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + location: str = ..., + multi_select_options: _Scalar = ..., + no_cache: _Flag = ..., + open_at: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort: Literal["default", "distance", "ratings"] = ..., + span: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + toggles: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_maps"], + api_key: str = ..., + center: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + location: str = ..., + multi_select_options: _Scalar = ..., + no_cache: _Flag = ..., + open_at: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort: Literal["default", "distance", "ratings"] = ..., + span: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + toggles: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AppleMapsPlacesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AppleMapsPlacesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_maps_places"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + muid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_maps_places"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + locale: Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"] = ..., + muid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AppleProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AppleProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["app"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_product"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["app"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AppleReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AppleReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + sort: Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["apple_reviews"], + api_key: str = ..., + cert: _Cert = ..., + country: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + sort: Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AutozoneTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AutozoneJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["autozone"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["autozone"], + api_key: str = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: AutozoneProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: AutozoneProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["autozone_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_token: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["autozone_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vehicle_engine: _Scalar = ..., + vehicle_make: _Scalar = ..., + vehicle_model: _Scalar = ..., + vehicle_submodel: _Scalar = ..., + vehicle_token: _Scalar = ..., + vehicle_type: Literal["car_truck", "motorcycle", "recreational"] = ..., + vehicle_year: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BaiduTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BaiduJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu"], + output: Literal["html", "md"], + api_key: str = ..., + bs: _Scalar = ..., + cert: _Cert = ..., + ct: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + f: _Scalar = ..., + gpc: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + oq: _Scalar = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + q5: _Scalar = ..., + q6: _Scalar = ..., + rn: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu"], + api_key: str = ..., + bs: _Scalar = ..., + cert: _Cert = ..., + ct: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + f: _Scalar = ..., + gpc: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + oq: _Scalar = ..., + output: Literal["json"] = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + q5: _Scalar = ..., + q6: _Scalar = ..., + rn: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BaiduMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BaiduMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu_maps"], + output: Literal["html", "md"], + api_key: str = ..., + c: _Number = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu_maps"], + api_key: str = ..., + c: _Number = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BaiduNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BaiduNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + ct: _Number = ..., + json_restrictor: _Scalar = ..., + medium: _Number = ..., + no_cache: _Flag = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rn: _Number = ..., + rtt: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["baidu_news"], + api_key: str = ..., + cert: _Cert = ..., + ct: _Number = ..., + json_restrictor: _Scalar = ..., + medium: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pn: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rn: _Number = ..., + rtt: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filters: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filters: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingCopilotTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingCopilotJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_copilot"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_copilot"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_images"], + output: Literal["html", "md"], + age: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + api_key: str = ..., + aspect: Literal["square", "wide", "tall"] = ..., + cc: str = ..., + cert: _Cert = ..., + color2: Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"] = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + face: Literal["face", "portrait"] = ..., + first: _Number = ..., + imagesize: Literal["small", "medium", "large", "wallpaper"] = ..., + json_restrictor: _Scalar = ..., + license: Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + photo: Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["strict", "moderate", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_images"], + age: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + api_key: str = ..., + aspect: Literal["square", "wide", "tall"] = ..., + cc: str = ..., + cert: _Cert = ..., + color2: Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"] = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + face: Literal["face", "portrait"] = ..., + first: _Number = ..., + imagesize: Literal["small", "medium", "large", "wallpaper"] = ..., + json_restrictor: _Scalar = ..., + license: Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + photo: Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["strict", "moderate", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_maps"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + count: _Number = ..., + cp: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_maps"], + api_key: str = ..., + cert: _Cert = ..., + count: _Number = ..., + cp: _Scalar = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_news"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + qft: Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""] = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_news"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + count: _Number = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + qft: Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""] = ..., + safeSearch: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingReverseImageTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingReverseImageJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_reverse_image"], + output: Literal["html", "md"], + api_key: str = ..., + cab: _Number = ..., + cal: _Number = ..., + car: _Number = ..., + cat: _Number = ..., + cert: _Cert = ..., + count: _Number = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_reverse_image"], + api_key: str = ..., + cab: _Number = ..., + cal: _Number = ..., + car: _Number = ..., + cat: _Number = ..., + cert: _Cert = ..., + count: _Number = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + efirst: _Number = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_shopping"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + efirst: _Number = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BingVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BingVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + date: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + length: Literal["short", "medium", "long"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + resolution: Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"] = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + source_site: Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["bing_videos"], + api_key: str = ..., + cc: str = ..., + cert: _Cert = ..., + date: Literal["lt1440", "lt10080", "lt43200", "lt525600"] = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + first: _Number = ..., + json_restrictor: _Scalar = ..., + length: Literal["short", "medium", "long"] = ..., + mkt: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + resolution: Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"] = ..., + setlang: Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"] = ..., + source_site: Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BookingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BookingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["booking"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + flex_window: _Number = ..., + free_cancellation: _Flag = ..., + hl: Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"] = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nflt: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + rooms: _Number = ..., + session_token: _Scalar = ..., + sort_by: Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["booking"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: str = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + flex_window: _Number = ..., + free_cancellation: _Flag = ..., + hl: Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"] = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nflt: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + rooms: _Number = ..., + session_token: _Scalar = ..., + sort_by: Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BraveTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BraveJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spellcheck: _Flag = ..., + stream: Optional[bool] = ..., + tf: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spellcheck: _Flag = ..., + stream: Optional[bool] = ..., + tf: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BraveAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BraveAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["off", "moderate", "strict"] = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + units_of_measurement: Literal["metric", "us"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + language: Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"] = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safeSearch: Literal["off", "moderate", "strict"] = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + units_of_measurement: Literal["metric", "us"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BraveImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BraveImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_images"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_images"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: BraveVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: BraveVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + date: Literal["past_day", "past_week", "past_month", "past_year"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["brave_videos"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"] = ..., + date: Literal["past_day", "past_week", "past_month", "past_year"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe_search: Literal["off", "moderate", "strict"] = ..., + spelling: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DoordashTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DoordashJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["doordash"], + output: Literal["html", "md"], + address: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + deals: _Flag = ..., + fastest: _Flag = ..., + json_restrictor: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pickup: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + store_type: Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["doordash"], + address: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + deals: _Flag = ..., + fastest: _Flag = ..., + json_restrictor: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pickup: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + store_type: Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckAiTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckAiJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duck_ai"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + model: Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"] = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duck_ai"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + model: Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckduckgoTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckduckgoJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + search_assist: _Flag = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + search_assist: _Flag = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckduckgoLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckduckgoLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_light"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_light"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckduckgoMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckduckgoMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_maps"], + output: Literal["html", "md"], + api_key: str = ..., + bbox: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + strict_bbox: _Number = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_maps"], + api_key: str = ..., + bbox: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + strict_bbox: _Number = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckduckgoNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckduckgoNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_news"], + api_key: str = ..., + cert: _Cert = ..., + df: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"] = ..., + m: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: DuckduckgoShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: DuckduckgoShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["duckduckgo_shopping"], + api_key: str = ..., + cert: _Cert = ..., + filters: _Scalar = ..., + json_restrictor: _Scalar = ..., + kl: Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: EbayTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: EbayJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay"], + output: Literal["html", "md"], + LH_ItemCondition: _Scalar = ..., + LH_PrefLoc: _Number = ..., + _blrs: _Flag = ..., + _dmd: _Number = ..., + _ipg: _Number = ..., + _nkw: _Scalar = ..., + _pgn: _Number = ..., + _salic: _Number = ..., + _sasl: _Scalar = ..., + _saslop: _Number = ..., + _sop: _Number = ..., + _stpos: _Scalar = ..., + _udhi: _Number = ..., + _udlo: _Number = ..., + api_key: str = ..., + buying_format: Literal["Auction", "BIN", "BO"] = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + popular_filters: _Scalar = ..., + proxies: _Proxies = ..., + show_only: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay"], + LH_ItemCondition: _Scalar = ..., + LH_PrefLoc: _Number = ..., + _blrs: _Flag = ..., + _dmd: _Number = ..., + _ipg: _Number = ..., + _nkw: _Scalar = ..., + _pgn: _Number = ..., + _salic: _Number = ..., + _sasl: _Scalar = ..., + _saslop: _Number = ..., + _sop: _Number = ..., + _stpos: _Scalar = ..., + _udhi: _Number = ..., + _udlo: _Number = ..., + api_key: str = ..., + buying_format: Literal["Auction", "BIN", "BO"] = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + popular_filters: _Scalar = ..., + proxies: _Proxies = ..., + show_only: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: EbayProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: EbayProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + lang: str = ..., + locale: str = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + shipping_country: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay_product"], + api_key: str = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + json_restrictor: _Scalar = ..., + lang: str = ..., + locale: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + shipping_country: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: EbaySellerTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: EbaySellerJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay_seller"], + output: Literal["html", "md"], + LH_ItemCondition: _Scalar = ..., + _ipg: _Number = ..., + _pgn: _Number = ..., + _sop: _Number = ..., + api_key: str = ..., + buying_format: _Number = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + free_shipping: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + seller_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["user", "store"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["ebay_seller"], + LH_ItemCondition: _Scalar = ..., + _ipg: _Number = ..., + _pgn: _Number = ..., + _sop: _Number = ..., + api_key: str = ..., + buying_format: _Number = ..., + cert: _Cert = ..., + ebay_domain: Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"] = ..., + free_shipping: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + seller_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["user", "store"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: EventbriteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: EventbriteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["eventbrite"], + output: Literal["html", "md"], + api_key: str = ..., + category: Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"] = ..., + cert: _Cert = ..., + date: Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"] = ..., + end_date: _Scalar = ..., + event_type: Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"] = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + online: _Flag = ..., + page: _Number = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["date"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["eventbrite"], + api_key: str = ..., + category: Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"] = ..., + cert: _Cert = ..., + date: Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"] = ..., + end_date: _Scalar = ..., + event_type: Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"] = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + online: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + price: Literal["free", "paid"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["date"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: ExtractTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: ExtractJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["extract"], + output: Literal["html", "md"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["extract"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: FacebookMarketplaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: FacebookMarketplaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["facebook_marketplace"], + output: Literal["html", "md"], + api_key: str = ..., + availability: Literal["available", "sold"] = ..., + category: Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"] = ..., + cert: _Cert = ..., + condition: _Scalar = ..., + days_since_listed: _Number = ..., + delivery_method: Literal["local_pick_up", "shipping"] = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort_by: Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["facebook_marketplace"], + api_key: str = ..., + availability: Literal["available", "sold"] = ..., + category: Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"] = ..., + cert: _Cert = ..., + condition: _Scalar = ..., + days_since_listed: _Number = ..., + delivery_method: Literal["local_pick_up", "shipping"] = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort_by: Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: FacebookProfileTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: FacebookProfileJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["facebook_profile"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["facebook_profile"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: Flightradar24TextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: Flightradar24JsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["flightradar24"], + output: Literal["html", "md"], + aircraft_type: _Scalar = ..., + airline: _Scalar = ..., + airport: _Scalar = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + callsign: _Scalar = ..., + cert: _Cert = ..., + departure_id: _Scalar = ..., + flight_number: _Scalar = ..., + json_restrictor: _Scalar = ..., + map_bounds: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + registration: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["flightradar24"], + aircraft_type: _Scalar = ..., + airline: _Scalar = ..., + airport: _Scalar = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + callsign: _Scalar = ..., + cert: _Cert = ..., + departure_id: _Scalar = ..., + flight_number: _Scalar = ..., + json_restrictor: _Scalar = ..., + map_bounds: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + registration: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GlassdoorCompaniesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GlassdoorCompaniesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_companies"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_companies"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + min_rating: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GlassdoorJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GlassdoorJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + date_posted: _Number = ..., + easy_apply: _Flag = ..., + employer_id: _Scalar = ..., + job_type: Literal["full_time", "part_time", "contract"] = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + max_salary: _Number = ..., + min_rating: _Number = ..., + min_salary: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + remote: _Flag = ..., + seniority_level: Literal["internship", "entry_level", "mid_senior_level", "director", "executive"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_jobs"], + api_key: str = ..., + cert: _Cert = ..., + date_posted: _Number = ..., + easy_apply: _Flag = ..., + employer_id: _Scalar = ..., + job_type: Literal["full_time", "part_time", "contract"] = ..., + json_restrictor: _Scalar = ..., + location: _Scalar = ..., + max_salary: _Number = ..., + min_rating: _Number = ..., + min_salary: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + remote: _Flag = ..., + seniority_level: Literal["internship", "entry_level", "mid_senior_level", "director", "executive"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GlassdoorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GlassdoorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + current_employees: _Flag = ..., + employer_id: _Scalar = ..., + employment_status: _Scalar = ..., + job_title: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: Literal["en", "fr", "de", "es", "pt", "it", "nl"] = ..., + location: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["glassdoor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + current_employees: _Flag = ..., + employer_id: _Scalar = ..., + employment_status: _Scalar = ..., + job_title: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: Literal["en", "fr", "de", "es", "pt", "it", "nl"] = ..., + location: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + color_scheme: Literal["light", "dark"] = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ibp: _Scalar = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + lat: _Number = ..., + location: str = ..., + lon: _Number = ..., + lr: _Scalar = ..., + lsig: _Scalar = ..., + ludocid: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + si: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbm: Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + udm: _Number = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAboutThisResultTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAboutThisResultJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_about_this_result"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ilps: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + req_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_about_this_result"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ilps: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + req_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAdsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAdsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAdsTransparencyCenterTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAdsTransparencyCenterJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads_transparency_center"], + output: Literal["html", "md"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_format: Literal["text", "image", "video"] = ..., + end_date: _Scalar = ..., + get_advertiser: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + platform: Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"] = ..., + political_ads: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads_transparency_center"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_format: Literal["text", "image", "video"] = ..., + end_date: _Scalar = ..., + get_advertiser: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + platform: Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"] = ..., + political_ads: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAdsTransparencyCenterAdDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAdsTransparencyCenterAdDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads_transparency_center_ad_details"], + output: Literal["html", "md"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + region: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ads_transparency_center_ad_details"], + advertiser_id: _Scalar = ..., + api_key: str = ..., + cert: _Cert = ..., + creative_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + region: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAiOverviewTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAiOverviewJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ai_overview"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_ai_overview"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + client: Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"] = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + client: Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"] = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleBooksTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleBooksJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_books"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + document_type: Literal["books", "magazines", "newspapers"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view: Literal["preview", "full"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_books"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + document_type: Literal["books", "magazines", "newspapers"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view: Literal["preview", "full"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleEventDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleEventDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_event_details"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + event_token: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nearby_places: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_results: _Flag = ..., + similar_events: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_event_details"], + api_key: str = ..., + cert: _Cert = ..., + event_token: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + nearby_places: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_results: _Flag = ..., + similar_events: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleEventsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleEventsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_events"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_events"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFinanceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFinanceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + window: Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + window: Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFinanceAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFinanceAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFinanceMarketsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFinanceMarketsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance_markets"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + trend: Literal["indexes"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_finance_markets"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + trend: Literal["indexes"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFlightsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFlightsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + booking_token: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + deep_search: _Flag = ..., + departure_id: _Scalar = ..., + departure_token: _Scalar = ..., + emissions: _Number = ..., + exclude_airlines: _Scalar = ..., + exclude_basic: _Flag = ..., + exclude_conns: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + layover_duration: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + multi_city_json: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + outbound_times: _Scalar = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + return_times: _Scalar = ..., + selected_flights_json: _Scalar = ..., + show_hidden: _Flag = ..., + sort_by: _Number = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + booking_token: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + deep_search: _Flag = ..., + departure_id: _Scalar = ..., + departure_token: _Scalar = ..., + emissions: _Number = ..., + exclude_airlines: _Scalar = ..., + exclude_basic: _Flag = ..., + exclude_conns: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + layover_duration: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + multi_city_json: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + outbound_times: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + return_times: _Scalar = ..., + selected_flights_json: _Scalar = ..., + show_hidden: _Flag = ..., + sort_by: _Number = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFlightsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFlightsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + exclude_regions: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + exclude_regions: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFlightsCalendarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFlightsCalendarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_calendar"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + date_range_end: _Scalar = ..., + date_range_start: _Scalar = ..., + departure_id: _Scalar = ..., + fixed_outbound_date: _Flag = ..., + gl: str = ..., + hl: str = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + round_trip_days: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_calendar"], + adults: _Number = ..., + api_key: str = ..., + arrival_id: _Scalar = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + date_range_end: _Scalar = ..., + date_range_start: _Scalar = ..., + departure_id: _Scalar = ..., + fixed_outbound_date: _Flag = ..., + gl: str = ..., + hl: str = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + round_trip_days: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleFlightsDealsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleFlightsDealsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_deals"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + trip_length: _Scalar = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_flights_deals"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + trip_length: _Scalar = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleForumsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleForumsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_forums"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_forums"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleGeminiTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleGeminiJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_gemini"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_gemini"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleHotelsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleHotelsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels"], + output: Literal["html", "md"], + adults: _Number = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + brands: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + eco_certified: _Flag = ..., + free_cancellation: _Flag = ..., + gl: str = ..., + hl: str = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: _Number = ..., + special_offers: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vacation_rentals: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels"], + adults: _Number = ..., + amenities: _Scalar = ..., + api_key: str = ..., + bathrooms: _Number = ..., + bedrooms: _Number = ..., + brands: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + eco_certified: _Flag = ..., + free_cancellation: _Flag = ..., + gl: str = ..., + hl: str = ..., + hotel_class: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + property_types: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort_by: _Number = ..., + special_offers: _Flag = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vacation_rentals: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleHotelsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleHotelsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleHotelsPhotosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleHotelsPhotosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_photos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_photos"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleHotelsPriceCalendarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleHotelsPriceCalendarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_price_calendar"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_price_calendar"], + adults: _Number = ..., + api_key: str = ..., + cert: _Cert = ..., + children: _Number = ..., + children_ages: _Scalar = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + end_date: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleHotelsReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleHotelsReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + category_token: _Scalar = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + sort_by: _Number = ..., + source_number: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_hotels_reviews"], + api_key: str = ..., + category_token: _Scalar = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + property_token: _Scalar = ..., + proxies: _Proxies = ..., + sort_by: _Number = ..., + source_number: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ijn: _Number = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + ijn: _Number = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleImagesLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleImagesLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + cr: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + end_date: _Scalar = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_color: Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"] = ..., + image_type: Literal["face", "photo", "clipart", "lineart", "animated"] = ..., + imgar: Literal["s", "t", "w", "xw"] = ..., + imgsz: Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"] = ..., + json_restrictor: _Scalar = ..., + licenses: Literal["f", "fc", "fm", "fmc", "cl", "ol"] = ..., + location: str = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + period_unit: Literal["s", "n", "h", "d", "w", "m", "y"] = ..., + period_value: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleImagesRelatedContentTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleImagesRelatedContentJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images_related_content"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + related_content_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_images_related_content"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + related_content_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleImmersiveProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleImmersiveProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_immersive_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + more_stores: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_immersive_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + more_stores: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lrad: _Number = ..., + ltype: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_jobs"], + api_key: str = ..., + cert: _Cert = ..., + chips: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lrad: _Number = ..., + ltype: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uds: _Scalar = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleJobsListingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleJobsListingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_jobs_listing"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_jobs_listing"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleLensTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleLensJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_lens"], + output: Literal["html", "md"], + api_key: str = ..., + auto_crop: _Flag = ..., + cert: _Cert = ..., + country: str = ..., + hl: str = ..., + image_id: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["all", "exact_matches", "visual_matches"] = ..., + url: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_lens"], + api_key: str = ..., + auto_crop: _Flag = ..., + cert: _Cert = ..., + country: str = ..., + hl: str = ..., + image_id: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["all", "exact_matches", "visual_matches"] = ..., + url: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleLocalTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleLocalJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_local"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + ludocid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_local"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + ludocid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleLocalServicesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleLocalServicesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_local_services"], + output: Literal["html", "md"], + api_key: str = ..., + bid: _Number = ..., + cert: _Cert = ..., + cid: _Number = ..., + data_cid: _Number = ..., + hl: str = ..., + job_type: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + pid: _Number = ..., + proxies: _Proxies = ..., + q: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_local_services"], + api_key: str = ..., + bid: _Number = ..., + cert: _Cert = ..., + cid: _Number = ..., + data_cid: _Number = ..., + hl: str = ..., + job_type: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pid: _Number = ..., + proxies: _Proxies = ..., + q: str = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data: _Scalar = ..., + data_cid: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + ll: _Scalar = ..., + location: str = ..., + lon: _Number = ..., + m: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + min_rating: _Number = ..., + nearby: _Flag = ..., + no_cache: _Flag = ..., + open_at_hour: _Number = ..., + open_on_day: Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"] = ..., + open_state: Literal["now", "24h"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["search", "place"] = ..., + verify: _Verify = ..., + z: _Number = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps"], + api_key: str = ..., + cert: _Cert = ..., + data: _Scalar = ..., + data_cid: _Scalar = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + ll: _Scalar = ..., + location: str = ..., + lon: _Number = ..., + m: _Number = ..., + max_price: _Number = ..., + min_price: _Number = ..., + min_rating: _Number = ..., + nearby: _Flag = ..., + no_cache: _Flag = ..., + open_at_hour: _Number = ..., + open_on_day: Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"] = ..., + open_state: Literal["now", "24h"] = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["search", "place"] = ..., + verify: _Verify = ..., + z: _Number = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + cp: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsContributorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsContributorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_contributor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + contributor_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_contributor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + contributor_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsDirectionsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsDirectionsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_directions"], + output: Literal["html", "md"], + api_key: str = ..., + avoid: _Scalar = ..., + cert: _Cert = ..., + distance_unit: _Number = ..., + end_addr: _Scalar = ..., + end_coords: _Scalar = ..., + end_data_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + prefer: _Scalar = ..., + proxies: _Proxies = ..., + route: _Number = ..., + start_addr: _Scalar = ..., + start_coords: _Scalar = ..., + start_data_id: _Scalar = ..., + stream: Optional[bool] = ..., + time: _Scalar = ..., + timeout: _Timeout = ..., + travel_mode: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_directions"], + api_key: str = ..., + avoid: _Scalar = ..., + cert: _Cert = ..., + distance_unit: _Number = ..., + end_addr: _Scalar = ..., + end_coords: _Scalar = ..., + end_data_id: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefer: _Scalar = ..., + proxies: _Proxies = ..., + route: _Number = ..., + start_addr: _Scalar = ..., + start_coords: _Scalar = ..., + start_data_id: _Scalar = ..., + stream: Optional[bool] = ..., + time: _Scalar = ..., + timeout: _Timeout = ..., + travel_mode: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsPhotoMetaTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsPhotoMetaJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_photo_meta"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_photo_meta"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsPhotosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsPhotosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_photos"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_photos"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsPostsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsPostsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_posts"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_posts"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleMapsReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleMapsReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_id: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_maps_reviews"], + api_key: str = ..., + cert: _Cert = ..., + data_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_id: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + publication_token: _Scalar = ..., + q: _Scalar = ..., + section_token: _Scalar = ..., + so: _Number = ..., + story_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_token: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_news"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + publication_token: _Scalar = ..., + q: _Scalar = ..., + section_token: _Scalar = ..., + so: _Number = ..., + story_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + topic_token: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleNewsLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleNewsLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_news_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_news_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePatentsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePatentsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_patents"], + output: Literal["html", "md"], + after: _Scalar = ..., + api_key: str = ..., + assignee: _Scalar = ..., + before: _Scalar = ..., + cert: _Cert = ..., + clustered: Literal["true"] = ..., + country: _Scalar = ..., + dups: Literal["language"] = ..., + inventor: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: _Scalar = ..., + litigation: Literal["YES", "NO"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + patents: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + scholar: _Flag = ..., + sort: Literal["new", "old"] = ..., + status: Literal["GRANT", "APPLICATION"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["PATENT", "DESIGN"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_patents"], + after: _Scalar = ..., + api_key: str = ..., + assignee: _Scalar = ..., + before: _Scalar = ..., + cert: _Cert = ..., + clustered: Literal["true"] = ..., + country: _Scalar = ..., + dups: Literal["language"] = ..., + inventor: _Scalar = ..., + json_restrictor: _Scalar = ..., + language: _Scalar = ..., + litigation: Literal["YES", "NO"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + patents: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + scholar: _Flag = ..., + sort: Literal["new", "old"] = ..., + status: Literal["GRANT", "APPLICATION"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["PATENT", "DESIGN"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePatentsDetailsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePatentsDetailsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_patents_details"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + patent_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_patents_details"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + patent_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePlayTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePlayJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + apps_category: Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"] = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "tablet", "tv", "chromebook", "watch", "car"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + apps_category: Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"] = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "tablet", "tv", "chromebook", "watch", "car"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePlayBooksTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePlayBooksJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_books"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + books_category: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + price: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_books"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + books_category: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + price: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePlayGamesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePlayGamesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_games"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + games_category: Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_games"], + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + games_category: Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"] = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + store_device: Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePlayMoviesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePlayMoviesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_movies"], + output: Literal["html", "md"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + movies_category: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_movies"], + age: Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"] = ..., + api_key: str = ..., + cert: _Cert = ..., + chart: _Scalar = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + movies_category: _Number = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + section_page_token: _Scalar = ..., + see_more_token: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GooglePlayProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GooglePlayProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_product"], + output: Literal["html", "md"], + all_reviews: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + platform: Literal["phone", "tablet", "watch", "chromebook", "tv", "car"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + season_id: _Scalar = ..., + sort_by: _Number = ..., + store: Literal["apps", "movies", "tv", "books", "audiobooks"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_play_product"], + all_reviews: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + platform: Literal["phone", "tablet", "watch", "chromebook", "tv", "car"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + season_id: _Scalar = ..., + sort_by: _Number = ..., + store: Literal["apps", "movies", "tv", "books", "audiobooks"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + offer_view: _Flag = ..., + page_token: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_product"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + offer_view: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleRelatedQuestionsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleRelatedQuestionsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_related_questions"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_related_questions"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleReverseImageTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleReverseImageJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_reverse_image"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_reverse_image"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + image_url: _Scalar = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleScholarTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleScholarJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar"], + output: Literal["html", "md"], + api_key: str = ..., + as_rr: _Flag = ..., + as_sdt: _Scalar = ..., + as_vis: _Flag = ..., + as_yhi: _Number = ..., + as_ylo: _Number = ..., + cert: _Cert = ..., + cites: _Scalar = ..., + cluster: _Scalar = ..., + filter: _Flag = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + scisbd: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar"], + api_key: str = ..., + as_rr: _Flag = ..., + as_sdt: _Scalar = ..., + as_vis: _Flag = ..., + as_yhi: _Number = ..., + as_ylo: _Number = ..., + cert: _Cert = ..., + cites: _Scalar = ..., + cluster: _Scalar = ..., + filter: _Flag = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + lr: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + scisbd: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleScholarAuthorTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleScholarAuthorJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_author"], + output: Literal["html", "md"], + api_key: str = ..., + author_id: _Scalar = ..., + cert: _Cert = ..., + citation_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["title", "pubdate"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view_op: Literal["view_citation", "list_colleagues"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_author"], + api_key: str = ..., + author_id: _Scalar = ..., + cert: _Cert = ..., + citation_id: _Scalar = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + sort: Literal["title", "pubdate"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + view_op: Literal["view_citation", "list_colleagues"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleScholarCaseLawTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleScholarCaseLawJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_case_law"], + output: Literal["html", "md"], + api_key: str = ..., + case_id: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_case_law"], + api_key: str = ..., + case_id: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleScholarCiteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleScholarCiteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_cite"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_scholar_cite"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleShoppingFiltersTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleShoppingFiltersJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping_filters"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + shoprs: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping_filters"], + api_key: str = ..., + cert: _Cert = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + shoprs: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleShoppingLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleShoppingLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping_light"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_shopping_light"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + free_shipping: _Flag = ..., + gl: Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"] = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + on_sale: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + shoprs: _Scalar = ..., + small_business: _Flag = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleShortVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleShortVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_short_videos"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_short_videos"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleSportsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleSportsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_sports"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + moa: _Scalar = ..., + mob: _Scalar = ..., + mpd: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + season_kgmid: _Scalar = ..., + sp: Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"] = ..., + stream: Optional[bool] = ..., + tab: Literal["gm", "sn", "pl", "br", "st", "rn", "ov"] = ..., + timeout: _Timeout = ..., + type: Literal["game", "league", "team"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_sports"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + kgmid: _Scalar = ..., + moa: _Scalar = ..., + mob: _Scalar = ..., + mpd: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + season_kgmid: _Scalar = ..., + sp: Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"] = ..., + stream: Optional[bool] = ..., + tab: Literal["gm", "sn", "pl", "br", "st", "rn", "ov"] = ..., + timeout: _Timeout = ..., + type: Literal["game", "league", "team"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTranslateTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTranslateJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_translate"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + to: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_translate"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + to: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTravelExploreTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTravelExploreJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_travel_explore"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + arrival_area_id: _Scalar = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + interest: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + travel_mode: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_travel_explore"], + adults: _Number = ..., + api_key: str = ..., + arrival_area_id: _Scalar = ..., + arrival_id: _Scalar = ..., + bags: _Number = ..., + cert: _Cert = ..., + children: _Number = ..., + currency: Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"] = ..., + departure_id: _Scalar = ..., + exclude_airlines: _Scalar = ..., + gl: str = ..., + hl: str = ..., + include_airlines: _Scalar = ..., + infants_in_seat: _Number = ..., + infants_on_lap: _Number = ..., + interest: _Number = ..., + json_restrictor: _Scalar = ..., + max_duration: _Number = ..., + max_price: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + outbound_date: _Scalar = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + return_date: _Scalar = ..., + stops: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + travel_class: _Number = ..., + travel_duration: _Number = ..., + travel_mode: _Number = ..., + type: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTrendsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTrendsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends"], + output: Literal["html", "md"], + api_key: str = ..., + cat: _Number = ..., + cert: _Cert = ..., + csv: _Flag = ..., + data_type: Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"] = ..., + date: _Scalar = ..., + geo: _Scalar = ..., + gprop: Literal["", "images", "news", "froogle", "youtube"] = ..., + hl: str = ..., + include_low_search_volume: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + region: Literal["COUNTRY", "REGION", "DMA", "CITY"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tz: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends"], + api_key: str = ..., + cat: _Number = ..., + cert: _Cert = ..., + csv: _Flag = ..., + data_type: Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"] = ..., + date: _Scalar = ..., + geo: _Scalar = ..., + gprop: Literal["", "images", "news", "froogle", "youtube"] = ..., + hl: str = ..., + include_low_search_volume: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + region: Literal["COUNTRY", "REGION", "DMA", "CITY"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tz: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTrendsAutocompleteTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTrendsAutocompleteJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_autocomplete"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_autocomplete"], + api_key: str = ..., + cert: _Cert = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTrendsNewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTrendsNewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_news"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_news"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleTrendsTrendingNowTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleTrendsTrendingNowJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_trending_now"], + output: Literal["html", "md"], + api_key: str = ..., + cat: Literal["all", "b", "e", "m", "t", "s", "h"] = ..., + category_id: _Number = ..., + cert: _Cert = ..., + date: _Scalar = ..., + frequency: Literal["daily", "realtime"] = ..., + geo: _Number = ..., + hl: str = ..., + hours: _Number = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + only_active: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_trends_trending_now"], + api_key: str = ..., + cat: Literal["all", "b", "e", "m", "t", "s", "h"] = ..., + category_id: _Number = ..., + cert: _Cert = ..., + date: _Scalar = ..., + frequency: Literal["daily", "realtime"] = ..., + geo: _Number = ..., + hl: str = ..., + hours: _Number = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + only_active: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_videos"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_videos"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: GoogleVideosLightTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: GoogleVideosLightJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_videos_light"], + output: Literal["html", "md"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["google_videos_light"], + api_key: str = ..., + as_dt: _Scalar = ..., + as_epq: _Scalar = ..., + as_eq: _Scalar = ..., + as_lq: _Scalar = ..., + as_nhi: _Scalar = ..., + as_nlo: _Scalar = ..., + as_oq: _Scalar = ..., + as_q: _Scalar = ..., + as_qdr: _Scalar = ..., + as_rq: _Scalar = ..., + as_sitesearch: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + filter: _Flag = ..., + gl: str = ..., + google_domain: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + location: str = ..., + lr: _Scalar = ..., + nfpr: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + tbs: _Scalar = ..., + timeout: _Timeout = ..., + uule: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: HomeDepotTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: HomeDepotJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["us", "ca"] = ..., + delivery_zip: _Scalar = ..., + filter: _Scalar = ..., + hd_filter_tokens: _Scalar = ..., + hd_sort: Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"] = ..., + json_restrictor: _Scalar = ..., + lowerbound: _Number = ..., + minmax: _Scalar = ..., + nao: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + pagesize: _Scalar = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"] = ..., + store: _Scalar = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + upperbound: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot"], + api_key: str = ..., + cert: _Cert = ..., + country: Literal["us", "ca"] = ..., + delivery_zip: _Scalar = ..., + filter: _Scalar = ..., + hd_filter_tokens: _Scalar = ..., + hd_sort: Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"] = ..., + json_restrictor: _Scalar = ..., + lowerbound: _Number = ..., + minmax: _Scalar = ..., + nao: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + pagesize: _Scalar = ..., + proxies: _Proxies = ..., + ps: _Number = ..., + q: _Scalar = ..., + sort: Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"] = ..., + store: _Scalar = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + upperbound: _Number = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: HomeDepotProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: HomeDepotProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + store_sku: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot_product"], + api_key: str = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + store_sku: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: HomeDepotProductReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: HomeDepotProductReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot_product_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + pagesize: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verified_purchases: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["home_depot_product_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + pagesize: _Scalar = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + term: _Scalar = ..., + timeout: _Timeout = ..., + verified_purchases: _Flag = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: IndeedJobsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: IndeedJobsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["indeed_jobs"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + fromage: _Number = ..., + json_restrictor: _Scalar = ..., + jt: Literal["fulltime", "parttime", "contract", "temporary", "internship"] = ..., + l: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort: Literal["date"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["indeed_jobs"], + api_key: str = ..., + cert: _Cert = ..., + fromage: _Number = ..., + json_restrictor: _Scalar = ..., + jt: Literal["fulltime", "parttime", "contract", "temporary", "internship"] = ..., + l: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + sort: Literal["date"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: InstagramPopularTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: InstagramPopularJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["instagram_popular"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + keyword: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["instagram_popular"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + keyword: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: InstagramProfileTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: InstagramProfileJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["instagram_profile"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["instagram_profile"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + profile_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: MetaAdLibraryTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: MetaAdLibraryJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["meta_ad_library"], + output: Literal["html", "md"], + active_status: Literal["active", "inactive", "all"] = ..., + ad_type: Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"] = ..., + api_key: str = ..., + cert: _Cert = ..., + content_languages: _Scalar = ..., + country: str = ..., + end_date: _Scalar = ..., + json_restrictor: _Scalar = ..., + media_type: Literal["all", "image", "meme", "image_and_meme", "video", "none"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + page_id: _Scalar = ..., + proxies: _Proxies = ..., + publisher_platforms: _Scalar = ..., + q: _Scalar = ..., + search_type: Literal["keyword_unordered", "keyword_exact_phrase"] = ..., + sort_by: Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["meta_ad_library"], + active_status: Literal["active", "inactive", "all"] = ..., + ad_type: Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"] = ..., + api_key: str = ..., + cert: _Cert = ..., + content_languages: _Scalar = ..., + country: str = ..., + end_date: _Scalar = ..., + json_restrictor: _Scalar = ..., + media_type: Literal["all", "image", "meme", "image_and_meme", "video", "none"] = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_id: _Scalar = ..., + proxies: _Proxies = ..., + publisher_platforms: _Scalar = ..., + q: _Scalar = ..., + search_type: Literal["keyword_unordered", "keyword_exact_phrase"] = ..., + sort_by: Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"] = ..., + start_date: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: NapaTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: NapaJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["napa"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["napa"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"] = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: NaverTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: NaverJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + page: _Number = ..., + period: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + where: Literal["nexearch", "web", "news", "video", "image"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + page: _Number = ..., + period: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: _Number = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + where: Literal["nexearch", "web", "news", "video", "image"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: NaverAiModeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: NaverAiModeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_ai_mode"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_ai_mode"], + api_key: str = ..., + cert: _Cert = ..., + continuable: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + subsequent_request_token: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: NaverAiOverviewTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: NaverAiOverviewJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_ai_overview"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_ai_overview"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page_token: _Scalar = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: NaverMapsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: NaverMapsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_maps"], + output: Literal["html", "md"], + adults: _Number = ..., + api_key: str = ..., + bookable: _Flag = ..., + center: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + coupon: _Flag = ..., + json_restrictor: _Scalar = ..., + naver_pay: _Flag = ..., + no_cache: _Flag = ..., + open_state: Literal["now"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + wheelchair_accessible: _Flag = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["naver_maps"], + adults: _Number = ..., + api_key: str = ..., + bookable: _Flag = ..., + center: _Scalar = ..., + cert: _Cert = ..., + check_in_date: _Scalar = ..., + check_out_date: _Scalar = ..., + children: _Number = ..., + coupon: _Flag = ..., + json_restrictor: _Scalar = ..., + naver_pay: _Flag = ..., + no_cache: _Flag = ..., + open_state: Literal["now"] = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + sort_by: Literal["distance"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + wheelchair_accessible: _Flag = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: OpenTableReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: OpenTableReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["open_table_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + open_table_domain: Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rid: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["open_table_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + open_table_domain: Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"] = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + rid: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: PinterestTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: PinterestJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["pinterest"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + less_ai: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["pins", "videos", "boards", "profiles", "products"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["pinterest"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + less_ai: _Flag = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["pins", "videos", "boards", "profiles", "products"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: SearchIndexTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: SearchIndexJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["search_index"], + output: Literal["html", "md"], + api_key: str = ..., + as_yhi: _Scalar = ..., + as_ylo: _Scalar = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + mode: Literal["deep"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + product_source: Literal["google", "amazon", "walmart", "ebay", "home_depot"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["web", "place", "product", "video", "publication"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["search_index"], + api_key: str = ..., + as_yhi: _Scalar = ..., + as_ylo: _Scalar = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + ll: _Scalar = ..., + mode: Literal["deep"] = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + product_source: Literal["google", "amazon", "walmart", "ebay", "home_depot"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + radius: _Number = ..., + safe: Literal["active", "off"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + type: Literal["web", "place", "product", "video", "publication"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TargetTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TargetJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["target"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["target"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + delivery_zip: _Scalar = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort: Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TiktokDiscoverTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TiktokDiscoverJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tiktok_discover"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + session_token: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tiktok_discover"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + num: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + session_token: _Scalar = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TiktokShopTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TiktokShopJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tiktok_shop"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + color_id: _Scalar = ..., + deals: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort: Literal["relevance", "best_seller", "newest"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tiktok_shop"], + api_key: str = ..., + category_id: _Scalar = ..., + cert: _Cert = ..., + color_id: _Scalar = ..., + deals: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Number = ..., + sort: Literal["relevance", "best_seller", "newest"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TraderJoesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TraderJoesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["trader_joes"], + output: Literal["html", "md"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + characteristics: _Scalar = ..., + json_restrictor: _Scalar = ..., + new_products: _Flag = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["price_low_to_high", "price_high_to_low", "popularity"] = ..., + store_id: _Number = ..., + stream: Optional[bool] = ..., + tags: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["trader_joes"], + api_key: str = ..., + category_id: _Number = ..., + cert: _Cert = ..., + characteristics: _Scalar = ..., + json_restrictor: _Scalar = ..., + new_products: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + sort_by: Literal["price_low_to_high", "price_high_to_low", "popularity"] = ..., + store_id: _Number = ..., + stream: Optional[bool] = ..., + tags: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TraderJoesProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TraderJoesProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["trader_joes_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["trader_joes_product"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TripadvisorTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TripadvisorJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + limit: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + ssrc: Literal["a", "r", "A", "h", "g", "v", "f"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + lat: _Number = ..., + limit: _Number = ..., + lon: _Number = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + ssrc: Literal["a", "r", "A", "h", "g", "v", "f"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TripadvisorPlaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TripadvisorPlaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor_place"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor_place"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: TripadvisorReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: TripadvisorReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language: Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"] = ..., + limit: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["most_recent", "detailed_review"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + type_of_visit: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["tripadvisor_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language: Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"] = ..., + limit: _Number = ..., + month: _Scalar = ..., + no_cache: _Flag = ..., + offset: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Scalar = ..., + sort_by: Literal["most_recent", "detailed_review"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + tripadvisor_domain: Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"] = ..., + type_of_visit: str = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: WalmartTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: WalmartJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart"], + output: Literal["html", "md"], + api_key: str = ..., + cat_id: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nd_en: _Flag = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + soft_sort: _Flag = ..., + sort: Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + walmart_domain: Literal["walmart.com", "walmart.com.mx"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart"], + api_key: str = ..., + cat_id: _Scalar = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + max_price: _Number = ..., + min_price: _Number = ..., + nd_en: _Flag = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + query: _Scalar = ..., + soft_sort: _Flag = ..., + sort: Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"] = ..., + spelling: _Flag = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + walmart_domain: Literal["walmart.com", "walmart.com.mx"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: WalmartProductTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: WalmartProductJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: WalmartProductReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: WalmartProductReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + sort: Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product_reviews"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + rating: _Number = ..., + sort: Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: WalmartProductSellersTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: WalmartProductSellersJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product_sellers"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_product_sellers"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + product_id: _Scalar = ..., + proxies: _Proxies = ..., + store_id: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: WalmartSellerTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: WalmartSellerJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_seller"], + output: Literal["html", "md"], + api_key: str = ..., + catalog_seller_id: _Scalar = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["walmart_seller"], + api_key: str = ..., + catalog_seller_id: _Scalar = ..., + cert: _Cert = ..., + facet: _Scalar = ..., + include_filters: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort: Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"] = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YahooTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YahooJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + d: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + fr2: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vc: str = ..., + verify: _Verify = ..., + vf: Literal["html", "pdf", "xls", "ppt", "doc", "txt"] = ..., + vl: Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"] = ..., + vm: Literal["r", "i", "p"] = ..., + vs: _Scalar = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + d: _Scalar = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + fr2: _Scalar = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vc: str = ..., + verify: _Verify = ..., + vf: Literal["html", "pdf", "xls", "ppt", "doc", "txt"] = ..., + vl: Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"] = ..., + vm: Literal["r", "i", "p"] = ..., + vs: _Scalar = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YahooImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YahooImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_images"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + imga: Literal["square", "wide", "tall"] = ..., + imgc: Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"] = ..., + imgf: Literal["face", "portrait", "nonportrait"] = ..., + imgl: Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"] = ..., + imgsz: Literal["small", "medium", "large", "wallpaper"] = ..., + imgt: Literal["day", "week", "month", "year"] = ..., + imgty: Literal["photo", "clipart", "linedrawing", "gif", "transparent"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yahoo_domain: Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_images"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + imga: Literal["square", "wide", "tall"] = ..., + imgc: Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"] = ..., + imgf: Literal["face", "portrait", "nonportrait"] = ..., + imgl: Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"] = ..., + imgsz: Literal["small", "medium", "large", "wallpaper"] = ..., + imgt: Literal["day", "week", "month", "year"] = ..., + imgty: Literal["photo", "clipart", "linedrawing", "gif", "transparent"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yahoo_domain: Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YahooShoppingTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YahooShoppingJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_shopping"], + output: Literal["html", "md"], + api_key: str = ..., + category_attr_values: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Scalar = ..., + merchants: _Scalar = ..., + min_price: _Scalar = ..., + no_cache: _Flag = ..., + order_by: Literal["ASC", "DESC"] = ..., + p: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort_by: Literal["price", "relevancy", "popularity", "discountPercentage"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_shopping"], + api_key: str = ..., + category_attr_values: _Scalar = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + limit: _Number = ..., + max_price: _Scalar = ..., + merchants: _Scalar = ..., + min_price: _Scalar = ..., + no_cache: _Flag = ..., + order_by: Literal["ASC", "DESC"] = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + page: _Number = ..., + proxies: _Proxies = ..., + sort_by: Literal["price", "relevancy", "popularity", "discountPercentage"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YahooTrendsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YahooTrendsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_trends"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + full_video_links: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_trends"], + api_key: str = ..., + cert: _Cert = ..., + full_video_links: _Flag = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YahooVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YahooVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_videos"], + output: Literal["html", "md"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + durs: Literal["short", "medium", "long"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vage: Literal["day", "week", "month", "year"] = ..., + verify: _Verify = ..., + vres: Literal["360p", "480p", "720p", "1080p"] = ..., + vsite: Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"] = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yahoo_videos"], + api_key: str = ..., + b: _Number = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + durs: Literal["short", "medium", "long"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + vage: Literal["day", "week", "month", "year"] = ..., + verify: _Verify = ..., + vres: Literal["360p", "480p", "720p", "1080p"] = ..., + vsite: Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"] = ..., + yahoo_domain: Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YandexTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YandexJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + family_mode: _Number = ..., + fix_typo: Literal["false", "true"] = ..., + groups_on_page: _Number = ..., + json_restrictor: _Scalar = ..., + lang: Literal["ru", "en", "be", "kk", "tr", "uk"] = ..., + lr: _Number = ..., + no_cache: _Flag = ..., + p: _Number = ..., + period: Literal["all", "day", "last_two_weeks", "month"] = ..., + proxies: _Proxies = ..., + sort_mode: Literal["relevance", "time"] = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex"], + api_key: str = ..., + cert: _Cert = ..., + family_mode: _Number = ..., + fix_typo: Literal["false", "true"] = ..., + groups_on_page: _Number = ..., + json_restrictor: _Scalar = ..., + lang: Literal["ru", "en", "be", "kk", "tr", "uk"] = ..., + lr: _Number = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Number = ..., + period: Literal["all", "day", "last_two_weeks", "month"] = ..., + proxies: _Proxies = ..., + sort_mode: Literal["relevance", "time"] = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YandexImagesTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YandexImagesJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex_images"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + color: Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"] = ..., + crop: _Scalar = ..., + crop_id: _Number = ..., + family_mode: _Number = ..., + file_type: Literal["jpg", "png", "gifan"] = ..., + height: _Number = ..., + image_type: Literal["photo", "clipart", "lineart", "face", "demotivator"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + orientation: Literal["horizontal", "vertical", "square"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + recent: _Flag = ..., + site: _Scalar = ..., + stream: Optional[bool] = ..., + tab: Literal["about", "similar"] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + url: _Scalar = ..., + verify: _Verify = ..., + width: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex_images"], + api_key: str = ..., + cert: _Cert = ..., + color: Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"] = ..., + crop: _Scalar = ..., + crop_id: _Number = ..., + family_mode: _Number = ..., + file_type: Literal["jpg", "png", "gifan"] = ..., + height: _Number = ..., + image_type: Literal["photo", "clipart", "lineart", "face", "demotivator"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + orientation: Literal["horizontal", "vertical", "square"] = ..., + output: Literal["json"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + recent: _Flag = ..., + site: _Scalar = ..., + stream: Optional[bool] = ..., + tab: Literal["about", "similar"] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + url: _Scalar = ..., + verify: _Verify = ..., + width: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YandexVideosTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YandexVideosJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex_videos"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + duration: Literal["short", "medium", "long"] = ..., + hd: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + p: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + within: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yandex_videos"], + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + duration: Literal["short", "medium", "long"] = ..., + hd: _Flag = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + p: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + text: _Scalar = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + within: _Number = ..., + yandex_domain: Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YelpTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YelpJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + find_desc: _Scalar = ..., + find_loc: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + sortby: Literal["recommended", "rating", "review_count"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp"], + api_key: str = ..., + cert: _Cert = ..., + find_desc: _Scalar = ..., + find_loc: _Scalar = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + sortby: Literal["recommended", "rating", "review_count"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YelpPlaceTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YelpPlaceJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp_place"], + output: Literal["html", "md"], + api_key: str = ..., + business_alert: _Flag = ..., + cert: _Cert = ..., + full_menu: _Flag = ..., + json_restrictor: _Scalar = ..., + menu_name: _Scalar = ..., + no_cache: _Flag = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp_place"], + api_key: str = ..., + business_alert: _Flag = ..., + cert: _Cert = ..., + full_menu: _Flag = ..., + json_restrictor: _Scalar = ..., + menu_name: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YelpReviewsTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YelpReviewsJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp_reviews"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + hl: Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + not_recommended: _Flag = ..., + not_recommended_start: _Number = ..., + num: _Number = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Scalar = ..., + sortby: Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["yelp_reviews"], + api_key: str = ..., + cert: _Cert = ..., + hl: Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"] = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + not_recommended: _Flag = ..., + not_recommended_start: _Number = ..., + num: _Number = ..., + output: Literal["json"] = ..., + place_id: _Scalar = ..., + proxies: _Proxies = ..., + q: _Scalar = ..., + rating: _Scalar = ..., + sortby: Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"] = ..., + start: _Number = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + yelp_domain: Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"] = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YoutubeTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YoutubeJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sp: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sp: _Scalar = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YoutubeChannelTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YoutubeChannelJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_channel"], + output: Literal["html", "md"], + about: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + channel_id: _Scalar = ..., + gl: str = ..., + hl: Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"] = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sort: Literal["latest", "popular", "oldest", "dd", "lad"] = ..., + stream: Optional[bool] = ..., + tab: Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_channel"], + about: _Flag = ..., + api_key: str = ..., + cert: _Cert = ..., + channel_id: _Scalar = ..., + gl: str = ..., + hl: Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"] = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + search_query: _Scalar = ..., + sort: Literal["latest", "popular", "oldest", "dd", "lad"] = ..., + stream: Optional[bool] = ..., + tab: Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YoutubeVideoTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YoutubeVideoJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_video"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_video"], + api_key: str = ..., + cert: _Cert = ..., + gl: str = ..., + hl: str = ..., + json_restrictor: _Scalar = ..., + next_page_token: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: YoutubeVideoTranscriptTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: YoutubeVideoTranscriptJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_video_transcript"], + output: Literal["html", "md"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language_code: str = ..., + no_cache: _Flag = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + title: _Scalar = ..., + type: Literal["asr"] = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["youtube_video_transcript"], + api_key: str = ..., + cert: _Cert = ..., + json_restrictor: _Scalar = ..., + language_code: str = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + title: _Scalar = ..., + type: Literal["asr"] = ..., + v: _Scalar = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: ZillowTextSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search( + params: ZillowJsonSearchParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search( + params: None = None, + *, + engine: Literal["zillow"], + output: Literal["html", "md"], + age_55_plus: Literal["include", "exclude", "only"] = ..., + amenities: _Scalar = ..., + api_key: str = ..., + basement: _Scalar = ..., + baths: _Scalar = ..., + beds: _Scalar = ..., + cert: _Cert = ..., + has_garage: _Flag = ..., + hide_no_date_listings: _Flag = ..., + hoa_max: _Number = ..., + home_type: _Scalar = ..., + json_restrictor: _Scalar = ..., + keywords: _Scalar = ..., + listing_features: _Scalar = ..., + listing_status: _Scalar = ..., + listing_type: _Scalar = ..., + lot_size: _Scalar = ..., + map_bounds: _Scalar = ..., + move_in_date: _Scalar = ..., + no_cache: _Flag = ..., + page: _Number = ..., + parking_spots: _Number = ..., + pets: _Scalar = ..., + price: _Scalar = ..., + price_reduction: _Flag = ..., + proxies: _Proxies = ..., + region_id: _Scalar = ..., + short_term_lease: _Flag = ..., + single_story: _Flag = ..., + sort_by: Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"] = ..., + space: Literal["any", "entire_place", "room"] = ..., + sqft: _Scalar = ..., + status_type: Literal["sale", "rent", "sold"] = ..., + stream: Optional[bool] = ..., + time_on_zillow: _Scalar = ..., + timeout: _Timeout = ..., + tours: _Scalar = ..., + verify: _Verify = ..., + view: _Scalar = ..., + year_built: _Scalar = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def search( + params: None = None, + *, + engine: Literal["zillow"], + age_55_plus: Literal["include", "exclude", "only"] = ..., + amenities: _Scalar = ..., + api_key: str = ..., + basement: _Scalar = ..., + baths: _Scalar = ..., + beds: _Scalar = ..., + cert: _Cert = ..., + has_garage: _Flag = ..., + hide_no_date_listings: _Flag = ..., + hoa_max: _Number = ..., + home_type: _Scalar = ..., + json_restrictor: _Scalar = ..., + keywords: _Scalar = ..., + listing_features: _Scalar = ..., + listing_status: _Scalar = ..., + listing_type: _Scalar = ..., + lot_size: _Scalar = ..., + map_bounds: _Scalar = ..., + move_in_date: _Scalar = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + page: _Number = ..., + parking_spots: _Number = ..., + pets: _Scalar = ..., + price: _Scalar = ..., + price_reduction: _Flag = ..., + proxies: _Proxies = ..., + region_id: _Scalar = ..., + short_term_lease: _Flag = ..., + single_story: _Flag = ..., + sort_by: Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"] = ..., + space: Literal["any", "entire_place", "room"] = ..., + sqft: _Scalar = ..., + status_type: Literal["sale", "rent", "sold"] = ..., + stream: Optional[bool] = ..., + time_on_zillow: _Scalar = ..., + timeout: _Timeout = ..., + tours: _Scalar = ..., + verify: _Verify = ..., + view: _Scalar = ..., + year_built: _Scalar = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def search( + params: Union[SearchParams, MutableMapping[str, Any]], + **kwargs: Any, +) -> Union[SerpResults, Any]: ... +@overload +def extract( + params: ExtractTextParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def extract( + params: ExtractJsonParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def extract( + params: None = None, + *, + output: Literal["html", "md"], + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> str: ... +@overload +def extract( + params: None = None, + *, + url: _Scalar, + api_key: str = ..., + cert: _Cert = ..., + device: Literal["desktop", "tablet", "mobile"] = ..., + exclude_tags: _Scalar = ..., + include_markdown: _Flag = ..., + include_sitemap: _Flag = ..., + include_subdomains: _Flag = ..., + include_tags: _Scalar = ..., + json_restrictor: _Scalar = ..., + max_depth: _Number = ..., + max_pages: _Number = ..., + mode: Literal["scrape", "map", "crawl"] = ..., + no_cache: _Flag = ..., + output: Literal["json"] = ..., + prefetch_delay: _Number = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., + zero_trace: _Flag = ..., +) -> SerpResults: ... +@overload +def extract( + params: Mapping[str, Any], + **kwargs: Any, +) -> Union[SerpResults, Any]: ... +@overload +def search_archive( + params: SearchArchiveTextParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search_archive( + params: SearchArchiveJsonParams, + *, + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search_archive( + params: None = None, + *, + output: Literal["html", "md"], + search_id: str, + api_key: str = ..., + cert: _Cert = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> str: ... +@overload +def search_archive( + params: None = None, + *, + search_id: str, + api_key: str = ..., + cert: _Cert = ..., + output: Literal["json"] = ..., + proxies: _Proxies = ..., + stream: Optional[bool] = ..., + timeout: _Timeout = ..., + verify: _Verify = ..., +) -> SerpResults: ... +@overload +def search_archive( + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + **kwargs: Any, +) -> Union[SerpResults, Any]: ... +def upload_image(image: Union[str, PathLike[str], IO[bytes]], *, cert: _Cert = ..., proxies: _Proxies = ..., stream: Optional[bool] = ..., timeout: _Timeout = ..., verify: _Verify = ..., **kwargs: Any) -> Dict[str, Any]: ... +def locations(params: Optional[MutableMapping[str, Any]] = None, **kwargs: Any) -> List[Dict[str, Any]]: ... +def account(params: Optional[MutableMapping[str, Any]] = None, **kwargs: Any) -> Dict[str, Any]: ... diff --git a/stubs/serpapi-stubs/engine_params.pyi b/stubs/serpapi-stubs/engine_params.pyi new file mode 100644 index 0000000..e18c1cf --- /dev/null +++ b/stubs/serpapi-stubs/engine_params.pyi @@ -0,0 +1,8154 @@ +# Generated by stubs/tools/generate_stubs.py from stubs/data/engines.json. +# Do not edit by hand; run `python stubs/tools/generate_stubs.py` instead. + +from typing import Union +from typing_extensions import Literal, NotRequired, Required, TypedDict, TypeAlias + +_Flag: TypeAlias = Union[bool, Literal[0, 1, "0", "1", "true", "false"]] +_Number: TypeAlias = Union[int, float, str] +_Scalar: TypeAlias = Union[str, int, float] + +AirbnbJsonSearchParams = TypedDict( + "AirbnbJsonSearchParams", + { + "accessibility_features": NotRequired[_Scalar], + "adults": NotRequired[_Number], + "airbnb_domain": NotRequired[str], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bathrooms": NotRequired[_Number], + "bedrooms": NotRequired[_Number], + "beds": NotRequired[_Number], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"]], + "engine": Required[Literal["airbnb"]], + "guest_favorite": NotRequired[_Flag], + "host_languages": NotRequired[_Scalar], + "infants": NotRequired[_Number], + "instant_book": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "luxe": NotRequired[_Flag], + "map_bounds": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "pets": NotRequired[_Number], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "room_type": NotRequired[Literal["entire_home", "private_room"]], + "self_check_in": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AirbnbTextSearchParams = TypedDict( + "AirbnbTextSearchParams", + { + "accessibility_features": NotRequired[_Scalar], + "adults": NotRequired[_Number], + "airbnb_domain": NotRequired[str], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bathrooms": NotRequired[_Number], + "bedrooms": NotRequired[_Number], + "beds": NotRequired[_Number], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["AED", "ARS", "AUD", "AWG", "BAM", "BBD", "BGN", "BHD", "BND", "BRL", "BTN", "BZD", "CAD", "CHF", "CLP", "CNY", "COP", "CRC", "CZK", "DKK", "EGP", "EUR", "FJD", "GBP", "GHS", "GTQ", "GYD", "HKD", "HNL", "HRK", "HUF", "IDR", "ILS", "INR", "JMD", "JOD", "JPY", "KES", "KRW", "KZT", "LAK", "LKR", "MAD", "MOP", "MXN", "MYR", "NOK", "NZD", "OMR", "PEN", "PGK", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TTD", "TWD", "UAH", "UGX", "USD", "UYU", "VND", "ZAR"]], + "engine": Required[Literal["airbnb"]], + "guest_favorite": NotRequired[_Flag], + "host_languages": NotRequired[_Scalar], + "infants": NotRequired[_Number], + "instant_book": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "luxe": NotRequired[_Flag], + "map_bounds": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "pets": NotRequired[_Number], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "room_type": NotRequired[Literal["entire_home", "private_room"]], + "self_check_in": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AirbnbSearchParams: TypeAlias = Union[AirbnbJsonSearchParams, AirbnbTextSearchParams] + +AmazonJsonSearchParams = TypedDict( + "AmazonJsonSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "dc": NotRequired[_Flag], + "delivery_city": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "emi": NotRequired[_Scalar], + "engine": Required[Literal["amazon"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "node": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "rh": NotRequired[_Scalar], + "s": NotRequired[Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"]], + "shipping_location": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonTextSearchParams = TypedDict( + "AmazonTextSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "dc": NotRequired[_Flag], + "delivery_city": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "emi": NotRequired[_Scalar], + "engine": Required[Literal["amazon"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "node": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "rh": NotRequired[_Scalar], + "s": NotRequired[Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"]], + "shipping_location": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonSearchParams: TypeAlias = Union[AmazonJsonSearchParams, AmazonTextSearchParams] + +AmazonAutocompleteJsonSearchParams = TypedDict( + "AmazonAutocompleteJsonSearchParams", + { + "amazon_department": NotRequired[Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"]], + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["amazon_autocomplete"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonAutocompleteTextSearchParams = TypedDict( + "AmazonAutocompleteTextSearchParams", + { + "amazon_department": NotRequired[Literal["aps", "alexa-skills", "vehicles", "amazon-devices", "amazonfresh", "amazon-global-store", "bazaar", "amazon-one-medical", "amazon-pharmacy", "warehouse-deals", "appliances", "mobile-apps", "arts-crafts", "audible", "automotive", "baby-products", "beauty", "stripbooks", "popular", "mobile", "fashion", "fashion-womens", "fashion-mens", "fashion-girls", "fashion-boys", "fashion-baby", "collectibles", "computers", "financial", "digital-music", "electronics", "lawngarden", "gift-cards", "grocery", "handmade", "hpc", "local-services", "garden", "industrial", "prime-exclusive", "digital-text", "fashion-luggage", "luxury", "magazines", "movies-tv", "mi", "office-products", "pets", "luxury-beauty", "instant-video", "samedaystore", "smart-home", "software", "sporting", "specialty-aps-sns", "subscribe-with-amazon", "tools", "toys-and-games", "under-ten-dollars", "videogames", "vons", "wholefoods"]], + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["amazon_autocomplete"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonAutocompleteSearchParams: TypeAlias = Union[AmazonAutocompleteJsonSearchParams, AmazonAutocompleteTextSearchParams] + +AmazonFreshJsonSearchParams = TypedDict( + "AmazonFreshJsonSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "dc": NotRequired[_Flag], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_fresh"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "language": NotRequired[Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"]], + "no_cache": NotRequired[_Flag], + "node": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "rh": NotRequired[_Scalar], + "s": NotRequired[Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonFreshTextSearchParams = TypedDict( + "AmazonFreshTextSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.it", "amazon.co.jp", "amazon.es", "amazon.co.uk", "amazon.com"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "dc": NotRequired[_Flag], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_fresh"]], + "json_restrictor": NotRequired[_Scalar], + "k": NotRequired[_Scalar], + "language": NotRequired[Literal["it_IT", "en_GB", "ja_JP", "en_US", "zh_CN", "es_ES", "pt_PT", "es_US"]], + "no_cache": NotRequired[_Flag], + "node": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "rh": NotRequired[_Scalar], + "s": NotRequired[Literal["relevanceblender", "price-asc-rank", "price-desc-rank", "review-rank", "date-desc-rank", "exact-aware-popularity-rank"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonFreshSearchParams: TypeAlias = Union[AmazonFreshJsonSearchParams, AmazonFreshTextSearchParams] + +AmazonProductJsonSearchParams = TypedDict( + "AmazonProductJsonSearchParams", + { + "all_related_products": NotRequired[_Flag], + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "asin": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "delivery_city": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_product"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "other_sellers": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "shipping_location": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonProductTextSearchParams = TypedDict( + "AmazonProductTextSearchParams", + { + "all_related_products": NotRequired[_Flag], + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.cn", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "asin": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "delivery_city": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_product"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "zh_CN", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "other_sellers": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "shipping_location": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonProductSearchParams: TypeAlias = Union[AmazonProductJsonSearchParams, AmazonProductTextSearchParams] + +AmazonPromotionJsonSearchParams = TypedDict( + "AmazonPromotionJsonSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_promotion"]], + "include_products": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "promotion_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonPromotionTextSearchParams = TypedDict( + "AmazonPromotionTextSearchParams", + { + "amazon_domain": NotRequired[Literal["amazon.com.au", "amazon.com.be", "amazon.com.br", "amazon.ca", "amazon.eg", "amazon.fr", "amazon.de", "amazon.in", "amazon.it", "amazon.co.jp", "amazon.nl", "amazon.pl", "amazon.sa", "amazon.sg", "amazon.es", "amazon.se", "amazon.com.tr", "amazon.ae", "amazon.co.uk", "amazon.com", "amazon.com.mx"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["amazon_promotion"]], + "include_products": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en_AU", "nl_BE", "fr_BE", "en_GB", "pt_BR", "en_CA", "fr_CA", "ar_AE", "en_AE", "fr_FR", "de_DE", "cs_CZ", "nl_NL", "pl_PL", "tr_TR", "da_DK", "en_IN", "hi_IN", "ta_IN", "te_IN", "kn_IN", "ml_IN", "bn_IN", "mr_IN", "it_IT", "ja_JP", "en_US", "zh_CN", "en_SG", "es_ES", "pt_PT", "sv_SE", "es_US", "es_MX"]], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "promotion_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AmazonPromotionSearchParams: TypeAlias = Union[AmazonPromotionJsonSearchParams, AmazonPromotionTextSearchParams] + +AppleAppStoreJsonSearchParams = TypedDict( + "AppleAppStoreJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Number], + "country": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "disallow_explicit": NotRequired[_Flag], + "engine": Required[Literal["apple_app_store"]], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "property": NotRequired[Literal["developer"]], + "term": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleAppStoreTextSearchParams = TypedDict( + "AppleAppStoreTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Number], + "country": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "disallow_explicit": NotRequired[_Flag], + "engine": Required[Literal["apple_app_store"]], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[Literal["pt-br", "it-it", "hi-in", "ca-es", "es-es", "zh-tw", "th-th", "da-dk", "fi-fi", "en-gb", "nl-nl", "pl-pl", "ro-ro", "zh-cn", "no-no", "pt-pt", "de-ch", "uk-ua", "en-us", "vi-vi", "sv-se", "en-ca", "fr-fr", "sk-sk", "zh-hk", "hr-hr", "en-au", "ko-kr", "tr-tr", "el-gr", "ms-my", "id-id", "cs-cz", "hu-hu", "fr-ca", "es-mx", "de-de", "ru-ru", "ja-jp"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "property": NotRequired[Literal["developer"]], + "term": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleAppStoreSearchParams: TypeAlias = Union[AppleAppStoreJsonSearchParams, AppleAppStoreTextSearchParams] + +AppleMapsJsonSearchParams = TypedDict( + "AppleMapsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "center": NotRequired[_Scalar], + "engine": Required[Literal["apple_maps"]], + "json_restrictor": NotRequired[_Scalar], + "locale": NotRequired[Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"]], + "location": NotRequired[str], + "multi_select_options": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "open_at": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "query": NotRequired[_Scalar], + "sort": NotRequired[Literal["default", "distance", "ratings"]], + "span": NotRequired[_Scalar], + "toggles": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleMapsTextSearchParams = TypedDict( + "AppleMapsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "center": NotRequired[_Scalar], + "engine": Required[Literal["apple_maps"]], + "json_restrictor": NotRequired[_Scalar], + "locale": NotRequired[Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"]], + "location": NotRequired[str], + "multi_select_options": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "open_at": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "query": NotRequired[_Scalar], + "sort": NotRequired[Literal["default", "distance", "ratings"]], + "span": NotRequired[_Scalar], + "toggles": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleMapsSearchParams: TypeAlias = Union[AppleMapsJsonSearchParams, AppleMapsTextSearchParams] + +AppleMapsPlacesJsonSearchParams = TypedDict( + "AppleMapsPlacesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["apple_maps_places"]], + "json_restrictor": NotRequired[_Scalar], + "locale": NotRequired[Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"]], + "muid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleMapsPlacesTextSearchParams = TypedDict( + "AppleMapsPlacesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["apple_maps_places"]], + "json_restrictor": NotRequired[_Scalar], + "locale": NotRequired[Literal["ar-SA", "bn-BD", "ca-ES", "cs-CZ", "da-DK", "de-DE", "el-GR", "en-AU", "en-GB", "en-US", "es-ES", "es-MX", "fi-FI", "fr-CA", "fr-FR", "gu-IN", "he-IL", "hi-IN", "hr-HR", "hu-HU", "id-ID", "it-IT", "ja-JP", "kn-IN", "ko-KR", "ml-IN", "mr-IN", "ms-MY", "nb-NO", "nl-NL", "or-IN", "pa-IN", "pl-PL", "pt-BR", "pt-PT", "ro-RO", "ru-RU", "sk-SK", "sl-SI", "sv-SE", "ta-IN", "te-IN", "th-TH", "tr-TR", "uk-UA", "ur-PK", "vi-VN", "zh-CN", "zh-HK", "zh-TW"]], + "muid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleMapsPlacesSearchParams: TypeAlias = Union[AppleMapsPlacesJsonSearchParams, AppleMapsPlacesTextSearchParams] + +AppleProductJsonSearchParams = TypedDict( + "AppleProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["apple_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "type": NotRequired[Literal["app"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleProductTextSearchParams = TypedDict( + "AppleProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["apple_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "type": NotRequired[Literal["app"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleProductSearchParams: TypeAlias = Union[AppleProductJsonSearchParams, AppleProductTextSearchParams] + +AppleReviewsJsonSearchParams = TypedDict( + "AppleReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["apple_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "product_id": NotRequired[_Scalar], + "sort": NotRequired[Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleReviewsTextSearchParams = TypedDict( + "AppleReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["apple_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "product_id": NotRequired[_Scalar], + "sort": NotRequired[Literal["mostrecent", "mosthelpful", "mostfavorable", "mostcritical"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AppleReviewsSearchParams: TypeAlias = Union[AppleReviewsJsonSearchParams, AppleReviewsTextSearchParams] + +AutozoneJsonSearchParams = TypedDict( + "AutozoneJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["autozone"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "ps": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"]], + "store_id": NotRequired[_Scalar], + "vehicle_engine": NotRequired[_Scalar], + "vehicle_make": NotRequired[_Scalar], + "vehicle_model": NotRequired[_Scalar], + "vehicle_submodel": NotRequired[_Scalar], + "vehicle_type": NotRequired[Literal["car_truck", "motorcycle", "recreational"]], + "vehicle_year": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AutozoneTextSearchParams = TypedDict( + "AutozoneTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["autozone"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "ps": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["featured", "price_low", "price_high", "recently_added", "rating_high", "best_seller"]], + "store_id": NotRequired[_Scalar], + "vehicle_engine": NotRequired[_Scalar], + "vehicle_make": NotRequired[_Scalar], + "vehicle_model": NotRequired[_Scalar], + "vehicle_submodel": NotRequired[_Scalar], + "vehicle_type": NotRequired[Literal["car_truck", "motorcycle", "recreational"]], + "vehicle_year": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AutozoneSearchParams: TypeAlias = Union[AutozoneJsonSearchParams, AutozoneTextSearchParams] + +AutozoneProductJsonSearchParams = TypedDict( + "AutozoneProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["autozone_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "vehicle_engine": NotRequired[_Scalar], + "vehicle_make": NotRequired[_Scalar], + "vehicle_model": NotRequired[_Scalar], + "vehicle_submodel": NotRequired[_Scalar], + "vehicle_token": NotRequired[_Scalar], + "vehicle_type": NotRequired[Literal["car_truck", "motorcycle", "recreational"]], + "vehicle_year": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AutozoneProductTextSearchParams = TypedDict( + "AutozoneProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["autozone_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "vehicle_engine": NotRequired[_Scalar], + "vehicle_make": NotRequired[_Scalar], + "vehicle_model": NotRequired[_Scalar], + "vehicle_submodel": NotRequired[_Scalar], + "vehicle_token": NotRequired[_Scalar], + "vehicle_type": NotRequired[Literal["car_truck", "motorcycle", "recreational"]], + "vehicle_year": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +AutozoneProductSearchParams: TypeAlias = Union[AutozoneProductJsonSearchParams, AutozoneProductTextSearchParams] + +BaiduJsonSearchParams = TypedDict( + "BaiduJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bs": NotRequired[_Scalar], + "ct": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["baidu"]], + "f": NotRequired[_Scalar], + "gpc": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "oq": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "pn": NotRequired[_Number], + "q": NotRequired[_Scalar], + "q5": NotRequired[_Scalar], + "q6": NotRequired[_Scalar], + "rn": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduTextSearchParams = TypedDict( + "BaiduTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bs": NotRequired[_Scalar], + "ct": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["baidu"]], + "f": NotRequired[_Scalar], + "gpc": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "oq": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "pn": NotRequired[_Number], + "q": NotRequired[_Scalar], + "q5": NotRequired[_Scalar], + "q6": NotRequired[_Scalar], + "rn": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduSearchParams: TypeAlias = Union[BaiduJsonSearchParams, BaiduTextSearchParams] + +BaiduMapsJsonSearchParams = TypedDict( + "BaiduMapsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "c": NotRequired[_Number], + "engine": Required[Literal["baidu_maps"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduMapsTextSearchParams = TypedDict( + "BaiduMapsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "c": NotRequired[_Number], + "engine": Required[Literal["baidu_maps"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduMapsSearchParams: TypeAlias = Union[BaiduMapsJsonSearchParams, BaiduMapsTextSearchParams] + +BaiduNewsJsonSearchParams = TypedDict( + "BaiduNewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "ct": NotRequired[_Number], + "engine": Required[Literal["baidu_news"]], + "json_restrictor": NotRequired[_Scalar], + "medium": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "pn": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rn": NotRequired[_Number], + "rtt": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduNewsTextSearchParams = TypedDict( + "BaiduNewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "ct": NotRequired[_Number], + "engine": Required[Literal["baidu_news"]], + "json_restrictor": NotRequired[_Scalar], + "medium": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "pn": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rn": NotRequired[_Number], + "rtt": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BaiduNewsSearchParams: TypeAlias = Union[BaiduNewsJsonSearchParams, BaiduNewsTextSearchParams] + +BingJsonSearchParams = TypedDict( + "BingJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing"]], + "filters": NotRequired[_Scalar], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingTextSearchParams = TypedDict( + "BingTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing"]], + "filters": NotRequired[_Scalar], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingSearchParams: TypeAlias = Union[BingJsonSearchParams, BingTextSearchParams] + +BingCopilotJsonSearchParams = TypedDict( + "BingCopilotJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["bing_copilot"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingCopilotTextSearchParams = TypedDict( + "BingCopilotTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["bing_copilot"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingCopilotSearchParams: TypeAlias = Union[BingCopilotJsonSearchParams, BingCopilotTextSearchParams] + +BingImagesJsonSearchParams = TypedDict( + "BingImagesJsonSearchParams", + { + "age": NotRequired[Literal["lt1440", "lt10080", "lt43200", "lt525600"]], + "api_key": NotRequired[str], + "aspect": NotRequired[Literal["square", "wide", "tall"]], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "color2": NotRequired[Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"]], + "count": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_images"]], + "face": NotRequired[Literal["face", "portrait"]], + "first": NotRequired[_Number], + "imagesize": NotRequired[Literal["small", "medium", "large", "wallpaper"]], + "json_restrictor": NotRequired[_Scalar], + "license": NotRequired[Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"]], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "photo": NotRequired[Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[Literal["strict", "moderate", "off"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingImagesTextSearchParams = TypedDict( + "BingImagesTextSearchParams", + { + "age": NotRequired[Literal["lt1440", "lt10080", "lt43200", "lt525600"]], + "api_key": NotRequired[str], + "aspect": NotRequired[Literal["square", "wide", "tall"]], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "color2": NotRequired[Literal["color", "bw", "FGcls_RED", "FGcls_ORANGE", "FGcls_YELLOW", "FGcls_GREEN", "FGcls_TEAL", "FGcls_BLUE", "FGcls_PURPLE", "FGcls_PINK", "FGcls_BROWN", "FGcls_BLACK", "FGcls_GRAY", "FGcls_WHITE"]], + "count": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_images"]], + "face": NotRequired[Literal["face", "portrait"]], + "first": NotRequired[_Number], + "imagesize": NotRequired[Literal["small", "medium", "large", "wallpaper"]], + "json_restrictor": NotRequired[_Scalar], + "license": NotRequired[Literal["Type-Any", "L1", "L2_L3_L4_L5_L6_L7", "L2_L3_L4", "L2_L3_L5_L6", "L2_L3"]], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "photo": NotRequired[Literal["photo", "clipart", "linedrawing", "animatedgif", "animatedgifhttps", "transparent", "shopping"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[Literal["strict", "moderate", "off"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingImagesSearchParams: TypeAlias = Union[BingImagesJsonSearchParams, BingImagesTextSearchParams] + +BingMapsJsonSearchParams = TypedDict( + "BingMapsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "count": NotRequired[_Number], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["bing_maps"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "setlang": NotRequired[Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingMapsTextSearchParams = TypedDict( + "BingMapsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "count": NotRequired[_Number], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["bing_maps"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "setlang": NotRequired[Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingMapsSearchParams: TypeAlias = Union[BingMapsJsonSearchParams, BingMapsTextSearchParams] + +BingNewsJsonSearchParams = TypedDict( + "BingNewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "count": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_news"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "qft": NotRequired[Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""]], + "safeSearch": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingNewsTextSearchParams = TypedDict( + "BingNewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "count": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_news"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "qft": NotRequired[Literal["interval=\"4\"", "interval=\"7\"", "interval=\"8\"", "interval=\"9\"", "sortbydate=\"1\""]], + "safeSearch": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingNewsSearchParams: TypeAlias = Union[BingNewsJsonSearchParams, BingNewsTextSearchParams] + +BingProductJsonSearchParams = TypedDict( + "BingProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["bing_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingProductTextSearchParams = TypedDict( + "BingProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["bing_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingProductSearchParams: TypeAlias = Union[BingProductJsonSearchParams, BingProductTextSearchParams] + +BingReverseImageJsonSearchParams = TypedDict( + "BingReverseImageJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cab": NotRequired[_Number], + "cal": NotRequired[_Number], + "car": NotRequired[_Number], + "cat": NotRequired[_Number], + "count": NotRequired[_Number], + "engine": Required[Literal["bing_reverse_image"]], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingReverseImageTextSearchParams = TypedDict( + "BingReverseImageTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cab": NotRequired[_Number], + "cal": NotRequired[_Number], + "car": NotRequired[_Number], + "cat": NotRequired[_Number], + "count": NotRequired[_Number], + "engine": Required[Literal["bing_reverse_image"]], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingReverseImageSearchParams: TypeAlias = Union[BingReverseImageJsonSearchParams, BingReverseImageTextSearchParams] + +BingShoppingJsonSearchParams = TypedDict( + "BingShoppingJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "efirst": NotRequired[_Number], + "engine": Required[Literal["bing_shopping"]], + "filters": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingShoppingTextSearchParams = TypedDict( + "BingShoppingTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "efirst": NotRequired[_Number], + "engine": Required[Literal["bing_shopping"]], + "filters": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingShoppingSearchParams: TypeAlias = Union[BingShoppingJsonSearchParams, BingShoppingTextSearchParams] + +BingVideosJsonSearchParams = TypedDict( + "BingVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "date": NotRequired[Literal["lt1440", "lt10080", "lt43200", "lt525600"]], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_videos"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "length": NotRequired[Literal["short", "medium", "long"]], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "price": NotRequired[Literal["free", "paid"]], + "q": NotRequired[_Scalar], + "resolution": NotRequired[Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"]], + "setlang": NotRequired[Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"]], + "source_site": NotRequired[Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingVideosTextSearchParams = TypedDict( + "BingVideosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cc": NotRequired[str], + "date": NotRequired[Literal["lt1440", "lt10080", "lt43200", "lt525600"]], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["bing_videos"]], + "first": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "length": NotRequired[Literal["short", "medium", "long"]], + "mkt": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "price": NotRequired[Literal["free", "paid"]], + "q": NotRequired[_Scalar], + "resolution": NotRequired[Literal["lowerthan_360p", "360p", "480p", "720p", "1080p"]], + "setlang": NotRequired[Literal["ar", "eu", "bn", "bg", "ca", "zh-hans", "zh-hant", "hr", "cs", "da", "nl", "en", "en-gb", "et", "fi", "fr", "gl", "de", "gu", "he", "hi", "hu", "is", "it", "jp", "kn", "ko", "lv", "lt", "ms", "ml", "mr", "nb", "pl", "pt-br", "pt-pt", "pa", "ro", "ru", "sr", "sk", "sl", "es", "sv", "ta", "te", "th", "tr", "uk", "vi"]], + "source_site": NotRequired[Literal["dailymotion.com", "vimeo.com", "metacafe.com", "hulu.com", "vevo.com", "myspace.com", "mtv.com", "cbsnews.com", "foxnews.com", "cnn.com", "msn.com"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BingVideosSearchParams: TypeAlias = Union[BingVideosJsonSearchParams, BingVideosTextSearchParams] + +BookingJsonSearchParams = TypedDict( + "BookingJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["booking"]], + "flex_window": NotRequired[_Number], + "free_cancellation": NotRequired[_Flag], + "hl": NotRequired[Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"]], + "hotel_class": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "limit": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "nflt": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "rooms": NotRequired[_Number], + "session_token": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BookingTextSearchParams = TypedDict( + "BookingTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[str], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["booking"]], + "flex_window": NotRequired[_Number], + "free_cancellation": NotRequired[_Flag], + "hl": NotRequired[Literal["en-us", "en-gb", "ar", "bg", "ca", "zh-cn", "zh-tw", "hr", "cs", "da", "nl", "et", "fi", "fr", "de", "el", "he", "hi", "hu", "is", "id", "it", "ja", "ko", "lv", "lt", "ms", "no", "pl", "pt-br", "pt-pt", "ro", "ru", "sr", "sk", "sl", "es", "es-ar", "es-mx", "sv", "tl", "th", "tr", "uk", "vi"]], + "hotel_class": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "limit": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "nflt": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "rooms": NotRequired[_Number], + "session_token": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["popularity", "upsort_bh", "price", "price_from_high_to_low", "review_score_and_price", "bayesian_review_score", "class", "class_asc", "class_and_price", "distance_from_search", "closest_beach_distance_v2", "closest_ski_lift_distance"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BookingSearchParams: TypeAlias = Union[BookingJsonSearchParams, BookingTextSearchParams] + +BraveJsonSearchParams = TypedDict( + "BraveJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"]], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spellcheck": NotRequired[_Flag], + "tf": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveTextSearchParams = TypedDict( + "BraveTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["all", "ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"]], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spellcheck": NotRequired[_Flag], + "tf": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveSearchParams: TypeAlias = Union[BraveJsonSearchParams, BraveTextSearchParams] + +BraveAiModeJsonSearchParams = TypedDict( + "BraveAiModeJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave_ai_mode"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"]], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[Literal["off", "moderate", "strict"]], + "subsequent_request_token": NotRequired[_Scalar], + "units_of_measurement": NotRequired[Literal["metric", "us"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveAiModeTextSearchParams = TypedDict( + "BraveAiModeTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave_ai_mode"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["az", "bg", "br", "ca", "cs", "cy", "da", "de", "el", "en", "es", "et", "eu", "fi", "fr", "gl", "hr", "hu", "id", "it", "ja", "ka", "ko", "lt", "lv", "ms", "nb", "nl", "pl", "pt", "ro", "ru", "sk", "sl", "sq", "sr", "sv", "sw", "th", "tr", "uk", "vi", "zh"]], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safeSearch": NotRequired[Literal["off", "moderate", "strict"]], + "subsequent_request_token": NotRequired[_Scalar], + "units_of_measurement": NotRequired[Literal["metric", "us"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveAiModeSearchParams: TypeAlias = Union[BraveAiModeJsonSearchParams, BraveAiModeTextSearchParams] + +BraveImagesJsonSearchParams = TypedDict( + "BraveImagesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave_images"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spelling": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveImagesTextSearchParams = TypedDict( + "BraveImagesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "engine": Required[Literal["brave_images"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spelling": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveImagesSearchParams: TypeAlias = Union[BraveImagesJsonSearchParams, BraveImagesTextSearchParams] + +BraveVideosJsonSearchParams = TypedDict( + "BraveVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "date": NotRequired[Literal["past_day", "past_week", "past_month", "past_year"]], + "engine": Required[Literal["brave_videos"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spelling": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveVideosTextSearchParams = TypedDict( + "BraveVideosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["ar", "au", "at", "be", "br", "ca", "cl", "cn", "dk", "fi", "fr", "de", "gr", "hk", "in", "id", "it", "jp", "kr", "my", "mx", "nl", "nz", "no", "pl", "pt", "ph", "ru", "sa", "sg", "za", "es", "se", "ch", "tw", "tr", "gb", "us"]], + "date": NotRequired[Literal["past_day", "past_week", "past_month", "past_year"]], + "engine": Required[Literal["brave_videos"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe_search": NotRequired[Literal["off", "moderate", "strict"]], + "spelling": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +BraveVideosSearchParams: TypeAlias = Union[BraveVideosJsonSearchParams, BraveVideosTextSearchParams] + +DoordashJsonSearchParams = TypedDict( + "DoordashJsonSearchParams", + { + "address": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "deals": NotRequired[_Flag], + "engine": Required[Literal["doordash"]], + "fastest": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "min_rating": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "pickup": NotRequired[_Flag], + "q": NotRequired[_Scalar], + "store_type": NotRequired[Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DoordashTextSearchParams = TypedDict( + "DoordashTextSearchParams", + { + "address": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "deals": NotRequired[_Flag], + "engine": Required[Literal["doordash"]], + "fastest": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "min_rating": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "pickup": NotRequired[_Flag], + "q": NotRequired[_Scalar], + "store_type": NotRequired[Literal["all", "restaurant", "grocery", "retail", "pets", "alcohol", "flowers"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DoordashSearchParams: TypeAlias = Union[DoordashJsonSearchParams, DoordashTextSearchParams] + +DuckAiJsonSearchParams = TypedDict( + "DuckAiJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["duck_ai"]], + "json_restrictor": NotRequired[_Scalar], + "model": NotRequired[Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"]], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckAiTextSearchParams = TypedDict( + "DuckAiTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["duck_ai"]], + "json_restrictor": NotRequired[_Scalar], + "model": NotRequired[Literal["gpt-5.6-luna", "gpt-6-luna", "gpt-5.4-mini", "claude-haiku-4-5", "mistral-small-2603", "tinfoil/gpt-oss-120b", "tinfoil/gemma4-31b"]], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckAiSearchParams: TypeAlias = Union[DuckAiJsonSearchParams, DuckAiTextSearchParams] + +DuckduckgoJsonSearchParams = TypedDict( + "DuckduckgoJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "m": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[_Number], + "search_assist": NotRequired[_Flag], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoTextSearchParams = TypedDict( + "DuckduckgoTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "m": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[_Number], + "search_assist": NotRequired[_Flag], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoSearchParams: TypeAlias = Union[DuckduckgoJsonSearchParams, DuckduckgoTextSearchParams] + +DuckduckgoLightJsonSearchParams = TypedDict( + "DuckduckgoLightJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_light"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoLightTextSearchParams = TypedDict( + "DuckduckgoLightTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_light"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoLightSearchParams: TypeAlias = Union[DuckduckgoLightJsonSearchParams, DuckduckgoLightTextSearchParams] + +DuckduckgoMapsJsonSearchParams = TypedDict( + "DuckduckgoMapsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bbox": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_maps"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "strict_bbox": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoMapsTextSearchParams = TypedDict( + "DuckduckgoMapsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bbox": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_maps"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "strict_bbox": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoMapsSearchParams: TypeAlias = Union[DuckduckgoMapsJsonSearchParams, DuckduckgoMapsTextSearchParams] + +DuckduckgoNewsJsonSearchParams = TypedDict( + "DuckduckgoNewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_news"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "m": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[_Number], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoNewsTextSearchParams = TypedDict( + "DuckduckgoNewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "df": NotRequired[_Scalar], + "engine": Required[Literal["duckduckgo_news"]], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "ct-ca", "cl-es", "cn-zh", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hk-tzh", "hu-hu", "is-is", "in-en", "id-en", "ie-en", "il-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "my-en", "mx-es", "nl-nl", "nz-en", "no-no", "pk-en", "pe-es", "ph-en", "pl-pl", "pt-pt", "ro-ro", "ru-ru", "xa-ar", "sg-en", "sk-sk", "sl-sl", "za-en", "es-ca", "es-es", "se-sv", "ch-de", "ch-fr", "tw-tzh", "th-en", "tr-tr", "us-en", "us-es", "ua-uk", "uk-en", "vn-en", "wt-wt"]], + "m": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[_Number], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoNewsSearchParams: TypeAlias = Union[DuckduckgoNewsJsonSearchParams, DuckduckgoNewsTextSearchParams] + +DuckduckgoShoppingJsonSearchParams = TypedDict( + "DuckduckgoShoppingJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["duckduckgo_shopping"]], + "filters": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoShoppingTextSearchParams = TypedDict( + "DuckduckgoShoppingTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["duckduckgo_shopping"]], + "filters": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "kl": NotRequired[Literal["ar-es", "au-en", "at-de", "be-fr", "be-nl", "br-pt", "bg-bg", "ca-en", "ca-fr", "cl-es", "co-es", "hr-hr", "cz-cs", "dk-da", "ee-et", "fi-fi", "fr-fr", "de-de", "gr-el", "hu-hu", "is-is", "in-en", "ie-en", "it-it", "jp-jp", "kr-kr", "lv-lv", "lt-lt", "mx-es", "nl-nl", "no-no", "pe-es", "pl-pl", "pt-pt", "ro-ro", "sk-sk", "sl-sl", "za-en", "es-es", "se-sv", "ch-de", "ch-fr", "tr-tr", "us-en", "us-es", "uk-en"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +DuckduckgoShoppingSearchParams: TypeAlias = Union[DuckduckgoShoppingJsonSearchParams, DuckduckgoShoppingTextSearchParams] + +EbayJsonSearchParams = TypedDict( + "EbayJsonSearchParams", + { + "LH_ItemCondition": NotRequired[_Scalar], + "LH_PrefLoc": NotRequired[_Number], + "_blrs": NotRequired[_Flag], + "_dmd": NotRequired[_Number], + "_ipg": NotRequired[_Number], + "_nkw": NotRequired[_Scalar], + "_pgn": NotRequired[_Number], + "_salic": NotRequired[_Number], + "_sasl": NotRequired[_Scalar], + "_saslop": NotRequired[_Number], + "_sop": NotRequired[_Number], + "_stpos": NotRequired[_Scalar], + "_udhi": NotRequired[_Number], + "_udlo": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "buying_format": NotRequired[Literal["Auction", "BIN", "BO"]], + "category_id": NotRequired[_Scalar], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "popular_filters": NotRequired[_Scalar], + "show_only": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbayTextSearchParams = TypedDict( + "EbayTextSearchParams", + { + "LH_ItemCondition": NotRequired[_Scalar], + "LH_PrefLoc": NotRequired[_Number], + "_blrs": NotRequired[_Flag], + "_dmd": NotRequired[_Number], + "_ipg": NotRequired[_Number], + "_nkw": NotRequired[_Scalar], + "_pgn": NotRequired[_Number], + "_salic": NotRequired[_Number], + "_sasl": NotRequired[_Scalar], + "_saslop": NotRequired[_Number], + "_sop": NotRequired[_Number], + "_stpos": NotRequired[_Scalar], + "_udhi": NotRequired[_Number], + "_udlo": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "buying_format": NotRequired[Literal["Auction", "BIN", "BO"]], + "category_id": NotRequired[_Scalar], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "popular_filters": NotRequired[_Scalar], + "show_only": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbaySearchParams: TypeAlias = Union[EbayJsonSearchParams, EbayTextSearchParams] + +EbayProductJsonSearchParams = TypedDict( + "EbayProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay_product"]], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[str], + "locale": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "shipping_country": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbayProductTextSearchParams = TypedDict( + "EbayProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay_product"]], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[str], + "locale": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "shipping_country": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbayProductSearchParams: TypeAlias = Union[EbayProductJsonSearchParams, EbayProductTextSearchParams] + +EbaySellerJsonSearchParams = TypedDict( + "EbaySellerJsonSearchParams", + { + "LH_ItemCondition": NotRequired[_Scalar], + "_ipg": NotRequired[_Number], + "_pgn": NotRequired[_Number], + "_sop": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "buying_format": NotRequired[_Number], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay_seller"]], + "free_shipping": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "seller_id": NotRequired[_Scalar], + "type": NotRequired[Literal["user", "store"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbaySellerTextSearchParams = TypedDict( + "EbaySellerTextSearchParams", + { + "LH_ItemCondition": NotRequired[_Scalar], + "_ipg": NotRequired[_Number], + "_pgn": NotRequired[_Number], + "_sop": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "buying_format": NotRequired[_Number], + "ebay_domain": NotRequired[Literal["ebay.com.au", "ebay.at", "ebay.ca", "ebay.fr", "ebay.de", "ebay.com.hk", "ebay.ie", "ebay.it", "ebay.com.my", "ebay.nl", "ebay.pl", "ebay.com.sg", "ebay.es", "ebay.ch", "ebay.co.uk", "ebay.com"]], + "engine": Required[Literal["ebay_seller"]], + "free_shipping": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "seller_id": NotRequired[_Scalar], + "type": NotRequired[Literal["user", "store"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EbaySellerSearchParams: TypeAlias = Union[EbaySellerJsonSearchParams, EbaySellerTextSearchParams] + +EventbriteJsonSearchParams = TypedDict( + "EventbriteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category": NotRequired[Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"]], + "date": NotRequired[Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["eventbrite"]], + "event_type": NotRequired[Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "online": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "price": NotRequired[Literal["free", "paid"]], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["date"]], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EventbriteTextSearchParams = TypedDict( + "EventbriteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category": NotRequired[Literal["business_and_professional", "science_and_technology", "music", "film_media_and_entertainment", "performing_and_visual_arts", "fashion_and_beauty", "health_and_wellness", "sports_and_fitness", "travel_and_outdoor", "food_and_drink", "charity_and_causes", "government_and_politics", "community_and_culture", "religion_and_spirituality", "family_and_education", "seasonal_and_holiday", "home_and_lifestyle", "auto_boat_and_air", "hobbies_and_special_interest", "school_activities", "other"]], + "date": NotRequired[Literal["today", "tomorrow", "this_weekend", "this_week", "next_week", "this_month", "next_month"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["eventbrite"]], + "event_type": NotRequired[Literal["conference", "seminar", "tradeshow", "convention", "festival", "concert", "screening", "dinner", "class", "meeting", "party", "rally", "tournament", "game", "race", "tour", "attraction", "camp", "appearance", "other"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "online": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "price": NotRequired[Literal["free", "paid"]], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["date"]], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +EventbriteSearchParams: TypeAlias = Union[EventbriteJsonSearchParams, EventbriteTextSearchParams] + +ExtractJsonSearchParams = TypedDict( + "ExtractJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["extract"]], + "exclude_tags": NotRequired[_Scalar], + "include_markdown": NotRequired[_Flag], + "include_sitemap": NotRequired[_Flag], + "include_subdomains": NotRequired[_Flag], + "include_tags": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_depth": NotRequired[_Number], + "max_pages": NotRequired[_Number], + "mode": NotRequired[Literal["scrape", "map", "crawl"]], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "prefetch_delay": NotRequired[_Number], + "timeout": NotRequired[_Number], + "url": Required[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ExtractTextSearchParams = TypedDict( + "ExtractTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["extract"]], + "exclude_tags": NotRequired[_Scalar], + "include_markdown": NotRequired[_Flag], + "include_sitemap": NotRequired[_Flag], + "include_subdomains": NotRequired[_Flag], + "include_tags": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_depth": NotRequired[_Number], + "max_pages": NotRequired[_Number], + "mode": NotRequired[Literal["scrape", "map", "crawl"]], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "prefetch_delay": NotRequired[_Number], + "timeout": NotRequired[_Number], + "url": Required[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ExtractSearchParams: TypeAlias = Union[ExtractJsonSearchParams, ExtractTextSearchParams] + +FacebookMarketplaceJsonSearchParams = TypedDict( + "FacebookMarketplaceJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "availability": NotRequired[Literal["available", "sold"]], + "category": NotRequired[Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"]], + "condition": NotRequired[_Scalar], + "days_since_listed": NotRequired[_Number], + "delivery_method": NotRequired[Literal["local_pick_up", "shipping"]], + "engine": Required[Literal["facebook_marketplace"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "sort_by": NotRequired[Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +FacebookMarketplaceTextSearchParams = TypedDict( + "FacebookMarketplaceTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "availability": NotRequired[Literal["available", "sold"]], + "category": NotRequired[Literal["apparel", "classifieds", "electronics", "entertainment", "family", "free", "garden", "hobbies", "home", "home-improvements", "instruments", "office-supplies", "pets", "propertyrentals", "sports", "toys", "vehicles"]], + "condition": NotRequired[_Scalar], + "days_since_listed": NotRequired[_Number], + "delivery_method": NotRequired[Literal["local_pick_up", "shipping"]], + "engine": Required[Literal["facebook_marketplace"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "sort_by": NotRequired[Literal["best_match", "distance_ascend", "creation_time_descend", "price_ascend", "price_descend"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +FacebookMarketplaceSearchParams: TypeAlias = Union[FacebookMarketplaceJsonSearchParams, FacebookMarketplaceTextSearchParams] + +FacebookProfileJsonSearchParams = TypedDict( + "FacebookProfileJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["facebook_profile"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "profile_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +FacebookProfileTextSearchParams = TypedDict( + "FacebookProfileTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["facebook_profile"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "profile_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +FacebookProfileSearchParams: TypeAlias = Union[FacebookProfileJsonSearchParams, FacebookProfileTextSearchParams] + +Flightradar24JsonSearchParams = TypedDict( + "Flightradar24JsonSearchParams", + { + "aircraft_type": NotRequired[_Scalar], + "airline": NotRequired[_Scalar], + "airport": NotRequired[_Scalar], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "callsign": NotRequired[_Scalar], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["flightradar24"]], + "flight_number": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "map_bounds": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "registration": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +Flightradar24TextSearchParams = TypedDict( + "Flightradar24TextSearchParams", + { + "aircraft_type": NotRequired[_Scalar], + "airline": NotRequired[_Scalar], + "airport": NotRequired[_Scalar], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "callsign": NotRequired[_Scalar], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["flightradar24"]], + "flight_number": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "map_bounds": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "registration": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +Flightradar24SearchParams: TypeAlias = Union[Flightradar24JsonSearchParams, Flightradar24TextSearchParams] + +GlassdoorCompaniesJsonSearchParams = TypedDict( + "GlassdoorCompaniesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["glassdoor_companies"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[_Scalar], + "min_rating": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorCompaniesTextSearchParams = TypedDict( + "GlassdoorCompaniesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["glassdoor_companies"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[_Scalar], + "min_rating": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorCompaniesSearchParams: TypeAlias = Union[GlassdoorCompaniesJsonSearchParams, GlassdoorCompaniesTextSearchParams] + +GlassdoorJobsJsonSearchParams = TypedDict( + "GlassdoorJobsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "date_posted": NotRequired[_Number], + "easy_apply": NotRequired[_Flag], + "employer_id": NotRequired[_Scalar], + "engine": Required[Literal["glassdoor_jobs"]], + "job_type": NotRequired[Literal["full_time", "part_time", "contract"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[_Scalar], + "max_salary": NotRequired[_Number], + "min_rating": NotRequired[_Number], + "min_salary": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "remote": NotRequired[_Flag], + "seniority_level": NotRequired[Literal["internship", "entry_level", "mid_senior_level", "director", "executive"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorJobsTextSearchParams = TypedDict( + "GlassdoorJobsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "date_posted": NotRequired[_Number], + "easy_apply": NotRequired[_Flag], + "employer_id": NotRequired[_Scalar], + "engine": Required[Literal["glassdoor_jobs"]], + "job_type": NotRequired[Literal["full_time", "part_time", "contract"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[_Scalar], + "max_salary": NotRequired[_Number], + "min_rating": NotRequired[_Number], + "min_salary": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "remote": NotRequired[_Flag], + "seniority_level": NotRequired[Literal["internship", "entry_level", "mid_senior_level", "director", "executive"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorJobsSearchParams: TypeAlias = Union[GlassdoorJobsJsonSearchParams, GlassdoorJobsTextSearchParams] + +GlassdoorReviewsJsonSearchParams = TypedDict( + "GlassdoorReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "current_employees": NotRequired[_Flag], + "employer_id": NotRequired[_Scalar], + "employment_status": NotRequired[_Scalar], + "engine": Required[Literal["glassdoor_reviews"]], + "job_title": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en", "fr", "de", "es", "pt", "it", "nl"]], + "location": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort_by": NotRequired[Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorReviewsTextSearchParams = TypedDict( + "GlassdoorReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "current_employees": NotRequired[_Flag], + "employer_id": NotRequired[_Scalar], + "employment_status": NotRequired[_Scalar], + "engine": Required[Literal["glassdoor_reviews"]], + "job_title": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["en", "fr", "de", "es", "pt", "it", "nl"]], + "location": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort_by": NotRequired[Literal["most_relevant", "newest", "oldest", "highest_rating", "lowest_rating"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GlassdoorReviewsSearchParams: TypeAlias = Union[GlassdoorReviewsJsonSearchParams, GlassdoorReviewsTextSearchParams] + +GoogleJsonSearchParams = TypedDict( + "GoogleJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "color_scheme": NotRequired[Literal["light", "dark"]], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": NotRequired[Literal["google"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ibp": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "lr": NotRequired[_Scalar], + "lsig": NotRequired[_Scalar], + "ludocid": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "safe": NotRequired[Literal["active", "off"]], + "si": NotRequired[_Scalar], + "start": NotRequired[_Number], + "tbm": NotRequired[Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"]], + "tbs": NotRequired[_Scalar], + "udm": NotRequired[_Number], + "uds": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTextSearchParams = TypedDict( + "GoogleTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "color_scheme": NotRequired[Literal["light", "dark"]], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": NotRequired[Literal["google"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ibp": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "lr": NotRequired[_Scalar], + "lsig": NotRequired[_Scalar], + "ludocid": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "safe": NotRequired[Literal["active", "off"]], + "si": NotRequired[_Scalar], + "start": NotRequired[_Number], + "tbm": NotRequired[Literal["isch", "lcl", "nws", "shop", "vid", "pts", "bks"]], + "tbs": NotRequired[_Scalar], + "udm": NotRequired[_Number], + "uds": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleSearchParams: TypeAlias = Union[GoogleJsonSearchParams, GoogleTextSearchParams] + +GoogleAboutThisResultJsonSearchParams = TypedDict( + "GoogleAboutThisResultJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_about_this_result"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ilps": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "req_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAboutThisResultTextSearchParams = TypedDict( + "GoogleAboutThisResultTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_about_this_result"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ilps": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "req_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAboutThisResultSearchParams: TypeAlias = Union[GoogleAboutThisResultJsonSearchParams, GoogleAboutThisResultTextSearchParams] + +GoogleAdsJsonSearchParams = TypedDict( + "GoogleAdsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_ads"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsTextSearchParams = TypedDict( + "GoogleAdsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_ads"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsSearchParams: TypeAlias = Union[GoogleAdsJsonSearchParams, GoogleAdsTextSearchParams] + +GoogleAdsTransparencyCenterJsonSearchParams = TypedDict( + "GoogleAdsTransparencyCenterJsonSearchParams", + { + "advertiser_id": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "creative_format": NotRequired[Literal["text", "image", "video"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_ads_transparency_center"]], + "get_advertiser": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "platform": NotRequired[Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"]], + "political_ads": NotRequired[_Flag], + "region": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "text": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsTransparencyCenterTextSearchParams = TypedDict( + "GoogleAdsTransparencyCenterTextSearchParams", + { + "advertiser_id": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "creative_format": NotRequired[Literal["text", "image", "video"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_ads_transparency_center"]], + "get_advertiser": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "platform": NotRequired[Literal["PLAY", "MAPS", "SEARCH", "SHOPPING", "YOUTUBE"]], + "political_ads": NotRequired[_Flag], + "region": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "text": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsTransparencyCenterSearchParams: TypeAlias = Union[GoogleAdsTransparencyCenterJsonSearchParams, GoogleAdsTransparencyCenterTextSearchParams] + +GoogleAdsTransparencyCenterAdDetailsJsonSearchParams = TypedDict( + "GoogleAdsTransparencyCenterAdDetailsJsonSearchParams", + { + "advertiser_id": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "creative_id": NotRequired[_Scalar], + "engine": Required[Literal["google_ads_transparency_center_ad_details"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "region": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsTransparencyCenterAdDetailsTextSearchParams = TypedDict( + "GoogleAdsTransparencyCenterAdDetailsTextSearchParams", + { + "advertiser_id": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "creative_id": NotRequired[_Scalar], + "engine": Required[Literal["google_ads_transparency_center_ad_details"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "region": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAdsTransparencyCenterAdDetailsSearchParams: TypeAlias = Union[GoogleAdsTransparencyCenterAdDetailsJsonSearchParams, GoogleAdsTransparencyCenterAdDetailsTextSearchParams] + +GoogleAiModeJsonSearchParams = TypedDict( + "GoogleAiModeJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "continuable": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_ai_mode"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAiModeTextSearchParams = TypedDict( + "GoogleAiModeTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "continuable": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_ai_mode"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAiModeSearchParams: TypeAlias = Union[GoogleAiModeJsonSearchParams, GoogleAiModeTextSearchParams] + +GoogleAiOverviewJsonSearchParams = TypedDict( + "GoogleAiOverviewJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_ai_overview"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAiOverviewTextSearchParams = TypedDict( + "GoogleAiOverviewTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_ai_overview"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAiOverviewSearchParams: TypeAlias = Union[GoogleAiOverviewJsonSearchParams, GoogleAiOverviewTextSearchParams] + +GoogleAutocompleteJsonSearchParams = TypedDict( + "GoogleAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "client": NotRequired[Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"]], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["google_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAutocompleteTextSearchParams = TypedDict( + "GoogleAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "client": NotRequired[Literal["chrome", "chrome-omni", "gws-wiz", "safari", "firefox", "psy-ab", "toolbar", "youtube", "gws-wiz-local"]], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["google_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleAutocompleteSearchParams: TypeAlias = Union[GoogleAutocompleteJsonSearchParams, GoogleAutocompleteTextSearchParams] + +GoogleBooksJsonSearchParams = TypedDict( + "GoogleBooksJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "document_type": NotRequired[Literal["books", "magazines", "newspapers"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_books"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "view": NotRequired[Literal["preview", "full"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleBooksTextSearchParams = TypedDict( + "GoogleBooksTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "document_type": NotRequired[Literal["books", "magazines", "newspapers"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_books"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "view": NotRequired[Literal["preview", "full"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleBooksSearchParams: TypeAlias = Union[GoogleBooksJsonSearchParams, GoogleBooksTextSearchParams] + +GoogleEventDetailsJsonSearchParams = TypedDict( + "GoogleEventDetailsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_event_details"]], + "event_token": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "nearby_places": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "search_results": NotRequired[_Flag], + "similar_events": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleEventDetailsTextSearchParams = TypedDict( + "GoogleEventDetailsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_event_details"]], + "event_token": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "nearby_places": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "search_results": NotRequired[_Flag], + "similar_events": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleEventDetailsSearchParams: TypeAlias = Union[GoogleEventDetailsJsonSearchParams, GoogleEventDetailsTextSearchParams] + +GoogleEventsJsonSearchParams = TypedDict( + "GoogleEventsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_events"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleEventsTextSearchParams = TypedDict( + "GoogleEventsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_events"]], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleEventsSearchParams: TypeAlias = Union[GoogleEventsJsonSearchParams, GoogleEventsTextSearchParams] + +GoogleFinanceJsonSearchParams = TypedDict( + "GoogleFinanceJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "window": NotRequired[Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceTextSearchParams = TypedDict( + "GoogleFinanceTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "window": NotRequired[Literal["1D", "5D", "1M", "6M", "YTD", "1Y", "5Y", "MAX"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceSearchParams: TypeAlias = Union[GoogleFinanceJsonSearchParams, GoogleFinanceTextSearchParams] + +GoogleFinanceAutocompleteJsonSearchParams = TypedDict( + "GoogleFinanceAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceAutocompleteTextSearchParams = TypedDict( + "GoogleFinanceAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceAutocompleteSearchParams: TypeAlias = Union[GoogleFinanceAutocompleteJsonSearchParams, GoogleFinanceAutocompleteTextSearchParams] + +GoogleFinanceMarketsJsonSearchParams = TypedDict( + "GoogleFinanceMarketsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance_markets"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "trend": NotRequired[Literal["indexes"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceMarketsTextSearchParams = TypedDict( + "GoogleFinanceMarketsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_finance_markets"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "trend": NotRequired[Literal["indexes"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFinanceMarketsSearchParams: TypeAlias = Union[GoogleFinanceMarketsJsonSearchParams, GoogleFinanceMarketsTextSearchParams] + +GoogleFlightsJsonSearchParams = TypedDict( + "GoogleFlightsJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "bags": NotRequired[_Number], + "booking_token": NotRequired[_Scalar], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "deep_search": NotRequired[_Flag], + "departure_id": NotRequired[_Scalar], + "departure_token": NotRequired[_Scalar], + "emissions": NotRequired[_Number], + "engine": Required[Literal["google_flights"]], + "exclude_airlines": NotRequired[_Scalar], + "exclude_basic": NotRequired[_Flag], + "exclude_conns": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "layover_duration": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "multi_city_json": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "outbound_times": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "return_date": NotRequired[_Scalar], + "return_times": NotRequired[_Scalar], + "selected_flights_json": NotRequired[_Scalar], + "show_hidden": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsTextSearchParams = TypedDict( + "GoogleFlightsTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "bags": NotRequired[_Number], + "booking_token": NotRequired[_Scalar], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "deep_search": NotRequired[_Flag], + "departure_id": NotRequired[_Scalar], + "departure_token": NotRequired[_Scalar], + "emissions": NotRequired[_Number], + "engine": Required[Literal["google_flights"]], + "exclude_airlines": NotRequired[_Scalar], + "exclude_basic": NotRequired[_Flag], + "exclude_conns": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "layover_duration": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "multi_city_json": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "outbound_times": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "return_date": NotRequired[_Scalar], + "return_times": NotRequired[_Scalar], + "selected_flights_json": NotRequired[_Scalar], + "show_hidden": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsSearchParams: TypeAlias = Union[GoogleFlightsJsonSearchParams, GoogleFlightsTextSearchParams] + +GoogleFlightsAutocompleteJsonSearchParams = TypedDict( + "GoogleFlightsAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_flights_autocomplete"]], + "exclude_regions": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsAutocompleteTextSearchParams = TypedDict( + "GoogleFlightsAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_flights_autocomplete"]], + "exclude_regions": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsAutocompleteSearchParams: TypeAlias = Union[GoogleFlightsAutocompleteJsonSearchParams, GoogleFlightsAutocompleteTextSearchParams] + +GoogleFlightsCalendarJsonSearchParams = TypedDict( + "GoogleFlightsCalendarJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "date_range_end": NotRequired[_Scalar], + "date_range_start": NotRequired[_Scalar], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_flights_calendar"]], + "fixed_outbound_date": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "round_trip_days": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsCalendarTextSearchParams = TypedDict( + "GoogleFlightsCalendarTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "date_range_end": NotRequired[_Scalar], + "date_range_start": NotRequired[_Scalar], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_flights_calendar"]], + "fixed_outbound_date": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "round_trip_days": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsCalendarSearchParams: TypeAlias = Union[GoogleFlightsCalendarJsonSearchParams, GoogleFlightsCalendarTextSearchParams] + +GoogleFlightsDealsJsonSearchParams = TypedDict( + "GoogleFlightsDealsJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_flights_deals"]], + "exclude_airlines": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "query": NotRequired[_Scalar], + "return_date": NotRequired[_Scalar], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "travel_duration": NotRequired[_Number], + "trip_length": NotRequired[_Scalar], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsDealsTextSearchParams = TypedDict( + "GoogleFlightsDealsTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_flights_deals"]], + "exclude_airlines": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "query": NotRequired[_Scalar], + "return_date": NotRequired[_Scalar], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "travel_duration": NotRequired[_Number], + "trip_length": NotRequired[_Scalar], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleFlightsDealsSearchParams: TypeAlias = Union[GoogleFlightsDealsJsonSearchParams, GoogleFlightsDealsTextSearchParams] + +GoogleForumsJsonSearchParams = TypedDict( + "GoogleForumsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_forums"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleForumsTextSearchParams = TypedDict( + "GoogleForumsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_forums"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleForumsSearchParams: TypeAlias = Union[GoogleForumsJsonSearchParams, GoogleForumsTextSearchParams] + +GoogleGeminiJsonSearchParams = TypedDict( + "GoogleGeminiJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_gemini"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleGeminiTextSearchParams = TypedDict( + "GoogleGeminiTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_gemini"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleGeminiSearchParams: TypeAlias = Union[GoogleGeminiJsonSearchParams, GoogleGeminiTextSearchParams] + +GoogleHotelsJsonSearchParams = TypedDict( + "GoogleHotelsJsonSearchParams", + { + "adults": NotRequired[_Number], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bathrooms": NotRequired[_Number], + "bedrooms": NotRequired[_Number], + "brands": NotRequired[_Scalar], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "eco_certified": NotRequired[_Flag], + "engine": Required[Literal["google_hotels"]], + "free_cancellation": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "hotel_class": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "property_token": NotRequired[_Scalar], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort_by": NotRequired[_Number], + "special_offers": NotRequired[_Flag], + "vacation_rentals": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsTextSearchParams = TypedDict( + "GoogleHotelsTextSearchParams", + { + "adults": NotRequired[_Number], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bathrooms": NotRequired[_Number], + "bedrooms": NotRequired[_Number], + "brands": NotRequired[_Scalar], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "eco_certified": NotRequired[_Flag], + "engine": Required[Literal["google_hotels"]], + "free_cancellation": NotRequired[_Flag], + "gl": NotRequired[str], + "hl": NotRequired[str], + "hotel_class": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "property_token": NotRequired[_Scalar], + "property_types": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort_by": NotRequired[_Number], + "special_offers": NotRequired[_Flag], + "vacation_rentals": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsSearchParams: TypeAlias = Union[GoogleHotelsJsonSearchParams, GoogleHotelsTextSearchParams] + +GoogleHotelsAutocompleteJsonSearchParams = TypedDict( + "GoogleHotelsAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "engine": Required[Literal["google_hotels_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsAutocompleteTextSearchParams = TypedDict( + "GoogleHotelsAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "engine": Required[Literal["google_hotels_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsAutocompleteSearchParams: TypeAlias = Union[GoogleHotelsAutocompleteJsonSearchParams, GoogleHotelsAutocompleteTextSearchParams] + +GoogleHotelsPhotosJsonSearchParams = TypedDict( + "GoogleHotelsPhotosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_hotels_photos"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "property_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsPhotosTextSearchParams = TypedDict( + "GoogleHotelsPhotosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_hotels_photos"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "property_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsPhotosSearchParams: TypeAlias = Union[GoogleHotelsPhotosJsonSearchParams, GoogleHotelsPhotosTextSearchParams] + +GoogleHotelsPriceCalendarJsonSearchParams = TypedDict( + "GoogleHotelsPriceCalendarJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_hotels_price_calendar"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "property_token": NotRequired[_Scalar], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsPriceCalendarTextSearchParams = TypedDict( + "GoogleHotelsPriceCalendarTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "children": NotRequired[_Number], + "children_ages": NotRequired[_Scalar], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_hotels_price_calendar"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "property_token": NotRequired[_Scalar], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsPriceCalendarSearchParams: TypeAlias = Union[GoogleHotelsPriceCalendarJsonSearchParams, GoogleHotelsPriceCalendarTextSearchParams] + +GoogleHotelsReviewsJsonSearchParams = TypedDict( + "GoogleHotelsReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_token": NotRequired[_Scalar], + "engine": Required[Literal["google_hotels_reviews"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "property_token": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "source_number": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsReviewsTextSearchParams = TypedDict( + "GoogleHotelsReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_token": NotRequired[_Scalar], + "engine": Required[Literal["google_hotels_reviews"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "property_token": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "source_number": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleHotelsReviewsSearchParams: TypeAlias = Union[GoogleHotelsReviewsJsonSearchParams, GoogleHotelsReviewsTextSearchParams] + +GoogleImagesJsonSearchParams = TypedDict( + "GoogleImagesJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "chips": NotRequired[_Scalar], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_images"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ijn": NotRequired[_Number], + "image_color": NotRequired[Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"]], + "image_type": NotRequired[Literal["face", "photo", "clipart", "lineart", "animated"]], + "imgar": NotRequired[Literal["s", "t", "w", "xw"]], + "imgsz": NotRequired[Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"]], + "json_restrictor": NotRequired[_Scalar], + "licenses": NotRequired[Literal["f", "fc", "fm", "fmc", "cl", "ol"]], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesTextSearchParams = TypedDict( + "GoogleImagesTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "chips": NotRequired[_Scalar], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_images"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "ijn": NotRequired[_Number], + "image_color": NotRequired[Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"]], + "image_type": NotRequired[Literal["face", "photo", "clipart", "lineart", "animated"]], + "imgar": NotRequired[Literal["s", "t", "w", "xw"]], + "imgsz": NotRequired[Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"]], + "json_restrictor": NotRequired[_Scalar], + "licenses": NotRequired[Literal["f", "fc", "fm", "fmc", "cl", "ol"]], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesSearchParams: TypeAlias = Union[GoogleImagesJsonSearchParams, GoogleImagesTextSearchParams] + +GoogleImagesLightJsonSearchParams = TypedDict( + "GoogleImagesLightJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_images_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "image_color": NotRequired[Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"]], + "image_type": NotRequired[Literal["face", "photo", "clipart", "lineart", "animated"]], + "imgar": NotRequired[Literal["s", "t", "w", "xw"]], + "imgsz": NotRequired[Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"]], + "json_restrictor": NotRequired[_Scalar], + "licenses": NotRequired[Literal["f", "fc", "fm", "fmc", "cl", "ol"]], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesLightTextSearchParams = TypedDict( + "GoogleImagesLightTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "cr": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["google_images_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "image_color": NotRequired[Literal["bw", "trans", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "white", "gray", "black", "brown"]], + "image_type": NotRequired[Literal["face", "photo", "clipart", "lineart", "animated"]], + "imgar": NotRequired[Literal["s", "t", "w", "xw"]], + "imgsz": NotRequired[Literal["l", "m", "i", "qsvga", "vga", "svga", "xga", "2mp", "4mp", "6mp", "8mp", "10mp", "12mp", "15mp", "20mp", "40mp", "70mp"]], + "json_restrictor": NotRequired[_Scalar], + "licenses": NotRequired[Literal["f", "fc", "fm", "fmc", "cl", "ol"]], + "location": NotRequired[str], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "period_unit": NotRequired[Literal["s", "n", "h", "d", "w", "m", "y"]], + "period_value": NotRequired[_Number], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "start_date": NotRequired[_Scalar], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesLightSearchParams: TypeAlias = Union[GoogleImagesLightJsonSearchParams, GoogleImagesLightTextSearchParams] + +GoogleImagesRelatedContentJsonSearchParams = TypedDict( + "GoogleImagesRelatedContentJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_images_related_content"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "related_content_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesRelatedContentTextSearchParams = TypedDict( + "GoogleImagesRelatedContentTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_images_related_content"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "related_content_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImagesRelatedContentSearchParams: TypeAlias = Union[GoogleImagesRelatedContentJsonSearchParams, GoogleImagesRelatedContentTextSearchParams] + +GoogleImmersiveProductJsonSearchParams = TypedDict( + "GoogleImmersiveProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_immersive_product"]], + "json_restrictor": NotRequired[_Scalar], + "more_stores": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImmersiveProductTextSearchParams = TypedDict( + "GoogleImmersiveProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_immersive_product"]], + "json_restrictor": NotRequired[_Scalar], + "more_stores": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleImmersiveProductSearchParams: TypeAlias = Union[GoogleImmersiveProductJsonSearchParams, GoogleImmersiveProductTextSearchParams] + +GoogleJobsJsonSearchParams = TypedDict( + "GoogleJobsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chips": NotRequired[_Scalar], + "engine": Required[Literal["google_jobs"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lrad": NotRequired[_Number], + "ltype": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "uds": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleJobsTextSearchParams = TypedDict( + "GoogleJobsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chips": NotRequired[_Scalar], + "engine": Required[Literal["google_jobs"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lrad": NotRequired[_Number], + "ltype": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "uds": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleJobsSearchParams: TypeAlias = Union[GoogleJobsJsonSearchParams, GoogleJobsTextSearchParams] + +GoogleJobsListingJsonSearchParams = TypedDict( + "GoogleJobsListingJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_jobs_listing"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleJobsListingTextSearchParams = TypedDict( + "GoogleJobsListingTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_jobs_listing"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleJobsListingSearchParams: TypeAlias = Union[GoogleJobsListingJsonSearchParams, GoogleJobsListingTextSearchParams] + +GoogleLensJsonSearchParams = TypedDict( + "GoogleLensJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "auto_crop": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["google_lens"]], + "hl": NotRequired[str], + "image_id": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "type": NotRequired[Literal["all", "exact_matches", "visual_matches"]], + "url": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLensTextSearchParams = TypedDict( + "GoogleLensTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "auto_crop": NotRequired[_Flag], + "country": NotRequired[str], + "engine": Required[Literal["google_lens"]], + "hl": NotRequired[str], + "image_id": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "type": NotRequired[Literal["all", "exact_matches", "visual_matches"]], + "url": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLensSearchParams: TypeAlias = Union[GoogleLensJsonSearchParams, GoogleLensTextSearchParams] + +GoogleLightJsonSearchParams = TypedDict( + "GoogleLightJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLightTextSearchParams = TypedDict( + "GoogleLightTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLightSearchParams: TypeAlias = Union[GoogleLightJsonSearchParams, GoogleLightTextSearchParams] + +GoogleLocalJsonSearchParams = TypedDict( + "GoogleLocalJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_local"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "ludocid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLocalTextSearchParams = TypedDict( + "GoogleLocalTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_local"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "ludocid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLocalSearchParams: TypeAlias = Union[GoogleLocalJsonSearchParams, GoogleLocalTextSearchParams] + +GoogleLocalServicesJsonSearchParams = TypedDict( + "GoogleLocalServicesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bid": NotRequired[_Number], + "cid": NotRequired[_Number], + "data_cid": NotRequired[_Number], + "engine": Required[Literal["google_local_services"]], + "hl": NotRequired[str], + "job_type": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "pid": NotRequired[_Number], + "q": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLocalServicesTextSearchParams = TypedDict( + "GoogleLocalServicesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bid": NotRequired[_Number], + "cid": NotRequired[_Number], + "data_cid": NotRequired[_Number], + "engine": Required[Literal["google_local_services"]], + "hl": NotRequired[str], + "job_type": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "pid": NotRequired[_Number], + "q": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleLocalServicesSearchParams: TypeAlias = Union[GoogleLocalServicesJsonSearchParams, GoogleLocalServicesTextSearchParams] + +GoogleMapsJsonSearchParams = TypedDict( + "GoogleMapsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data": NotRequired[_Scalar], + "data_cid": NotRequired[_Scalar], + "engine": Required[Literal["google_maps"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "ll": NotRequired[_Scalar], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "m": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "min_rating": NotRequired[_Number], + "nearby": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "open_at_hour": NotRequired[_Number], + "open_on_day": NotRequired[Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"]], + "open_state": NotRequired[Literal["now", "24h"]], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "type": NotRequired[Literal["search", "place"]], + "z": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsTextSearchParams = TypedDict( + "GoogleMapsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data": NotRequired[_Scalar], + "data_cid": NotRequired[_Scalar], + "engine": Required[Literal["google_maps"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "ll": NotRequired[_Scalar], + "location": NotRequired[str], + "lon": NotRequired[_Number], + "m": NotRequired[_Number], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "min_rating": NotRequired[_Number], + "nearby": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "open_at_hour": NotRequired[_Number], + "open_on_day": NotRequired[Literal["mon", "tue", "wed", "thu", "fri", "sat", "sun"]], + "open_state": NotRequired[Literal["now", "24h"]], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "start": NotRequired[_Number], + "type": NotRequired[Literal["search", "place"]], + "z": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsSearchParams: TypeAlias = Union[GoogleMapsJsonSearchParams, GoogleMapsTextSearchParams] + +GoogleMapsAutocompleteJsonSearchParams = TypedDict( + "GoogleMapsAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "ll": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsAutocompleteTextSearchParams = TypedDict( + "GoogleMapsAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cp": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_autocomplete"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "ll": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsAutocompleteSearchParams: TypeAlias = Union[GoogleMapsAutocompleteJsonSearchParams, GoogleMapsAutocompleteTextSearchParams] + +GoogleMapsContributorReviewsJsonSearchParams = TypedDict( + "GoogleMapsContributorReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "contributor_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_contributor_reviews"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsContributorReviewsTextSearchParams = TypedDict( + "GoogleMapsContributorReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "contributor_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_contributor_reviews"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsContributorReviewsSearchParams: TypeAlias = Union[GoogleMapsContributorReviewsJsonSearchParams, GoogleMapsContributorReviewsTextSearchParams] + +GoogleMapsDirectionsJsonSearchParams = TypedDict( + "GoogleMapsDirectionsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "avoid": NotRequired[_Scalar], + "distance_unit": NotRequired[_Number], + "end_addr": NotRequired[_Scalar], + "end_coords": NotRequired[_Scalar], + "end_data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_directions"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "prefer": NotRequired[_Scalar], + "route": NotRequired[_Number], + "start_addr": NotRequired[_Scalar], + "start_coords": NotRequired[_Scalar], + "start_data_id": NotRequired[_Scalar], + "time": NotRequired[_Scalar], + "travel_mode": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsDirectionsTextSearchParams = TypedDict( + "GoogleMapsDirectionsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "avoid": NotRequired[_Scalar], + "distance_unit": NotRequired[_Number], + "end_addr": NotRequired[_Scalar], + "end_coords": NotRequired[_Scalar], + "end_data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_directions"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "prefer": NotRequired[_Scalar], + "route": NotRequired[_Number], + "start_addr": NotRequired[_Scalar], + "start_coords": NotRequired[_Scalar], + "start_data_id": NotRequired[_Scalar], + "time": NotRequired[_Scalar], + "travel_mode": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsDirectionsSearchParams: TypeAlias = Union[GoogleMapsDirectionsJsonSearchParams, GoogleMapsDirectionsTextSearchParams] + +GoogleMapsPhotoMetaJsonSearchParams = TypedDict( + "GoogleMapsPhotoMetaJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_photo_meta"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPhotoMetaTextSearchParams = TypedDict( + "GoogleMapsPhotoMetaTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_photo_meta"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPhotoMetaSearchParams: TypeAlias = Union[GoogleMapsPhotoMetaJsonSearchParams, GoogleMapsPhotoMetaTextSearchParams] + +GoogleMapsPhotosJsonSearchParams = TypedDict( + "GoogleMapsPhotosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_photos"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPhotosTextSearchParams = TypedDict( + "GoogleMapsPhotosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_photos"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPhotosSearchParams: TypeAlias = Union[GoogleMapsPhotosJsonSearchParams, GoogleMapsPhotosTextSearchParams] + +GoogleMapsPostsJsonSearchParams = TypedDict( + "GoogleMapsPostsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_posts"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPostsTextSearchParams = TypedDict( + "GoogleMapsPostsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_posts"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsPostsSearchParams: TypeAlias = Union[GoogleMapsPostsJsonSearchParams, GoogleMapsPostsTextSearchParams] + +GoogleMapsReviewsJsonSearchParams = TypedDict( + "GoogleMapsReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_reviews"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"]], + "topic_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsReviewsTextSearchParams = TypedDict( + "GoogleMapsReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "data_id": NotRequired[_Scalar], + "engine": Required[Literal["google_maps_reviews"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["qualityScore", "newestFirst", "ratingHigh", "ratingLow"]], + "topic_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleMapsReviewsSearchParams: TypeAlias = Union[GoogleMapsReviewsJsonSearchParams, GoogleMapsReviewsTextSearchParams] + +GoogleNewsJsonSearchParams = TypedDict( + "GoogleNewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_news"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "publication_token": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "section_token": NotRequired[_Scalar], + "so": NotRequired[_Number], + "story_token": NotRequired[_Scalar], + "topic_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleNewsTextSearchParams = TypedDict( + "GoogleNewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_news"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "publication_token": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "section_token": NotRequired[_Scalar], + "so": NotRequired[_Number], + "story_token": NotRequired[_Scalar], + "topic_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleNewsSearchParams: TypeAlias = Union[GoogleNewsJsonSearchParams, GoogleNewsTextSearchParams] + +GoogleNewsLightJsonSearchParams = TypedDict( + "GoogleNewsLightJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_news_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleNewsLightTextSearchParams = TypedDict( + "GoogleNewsLightTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_news_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleNewsLightSearchParams: TypeAlias = Union[GoogleNewsLightJsonSearchParams, GoogleNewsLightTextSearchParams] + +GooglePatentsJsonSearchParams = TypedDict( + "GooglePatentsJsonSearchParams", + { + "after": NotRequired[_Scalar], + "api_key": NotRequired[str], + "assignee": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "before": NotRequired[_Scalar], + "clustered": NotRequired[Literal["true"]], + "country": NotRequired[_Scalar], + "dups": NotRequired[Literal["language"]], + "engine": Required[Literal["google_patents"]], + "inventor": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[_Scalar], + "litigation": NotRequired[Literal["YES", "NO"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "patents": NotRequired[_Flag], + "q": NotRequired[_Scalar], + "scholar": NotRequired[_Flag], + "sort": NotRequired[Literal["new", "old"]], + "status": NotRequired[Literal["GRANT", "APPLICATION"]], + "type": NotRequired[Literal["PATENT", "DESIGN"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePatentsTextSearchParams = TypedDict( + "GooglePatentsTextSearchParams", + { + "after": NotRequired[_Scalar], + "api_key": NotRequired[str], + "assignee": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "before": NotRequired[_Scalar], + "clustered": NotRequired[Literal["true"]], + "country": NotRequired[_Scalar], + "dups": NotRequired[Literal["language"]], + "engine": Required[Literal["google_patents"]], + "inventor": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[_Scalar], + "litigation": NotRequired[Literal["YES", "NO"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "patents": NotRequired[_Flag], + "q": NotRequired[_Scalar], + "scholar": NotRequired[_Flag], + "sort": NotRequired[Literal["new", "old"]], + "status": NotRequired[Literal["GRANT", "APPLICATION"]], + "type": NotRequired[Literal["PATENT", "DESIGN"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePatentsSearchParams: TypeAlias = Union[GooglePatentsJsonSearchParams, GooglePatentsTextSearchParams] + +GooglePatentsDetailsJsonSearchParams = TypedDict( + "GooglePatentsDetailsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_patents_details"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "patent_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePatentsDetailsTextSearchParams = TypedDict( + "GooglePatentsDetailsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_patents_details"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "patent_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePatentsDetailsSearchParams: TypeAlias = Union[GooglePatentsDetailsJsonSearchParams, GooglePatentsDetailsTextSearchParams] + +GooglePlayJsonSearchParams = TypedDict( + "GooglePlayJsonSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "apps_category": NotRequired[Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"]], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "store_device": NotRequired[Literal["phone", "tablet", "tv", "chromebook", "watch", "car"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayTextSearchParams = TypedDict( + "GooglePlayTextSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "apps_category": NotRequired[Literal["ART_AND_DESIGN", "AUTO_AND_VEHICLES", "BEAUTY", "BOOKS_AND_REFERENCE", "BUSINESS", "COMICS", "COMMUNICATION", "DATING", "EDUCATION", "ENTERTAINMENT", "EVENTS", "FINANCE", "FOOD_AND_DRINK", "HEALTH_AND_FITNESS", "HOUSE_AND_HOME", "LIBRARIES_AND_DEMO", "LIFESTYLE", "MAPS_AND_NAVIGATION", "MEDICAL", "MUSIC_AND_AUDIO", "NEWS_AND_MAGAZINES", "PARENTING", "PERSONALIZATION", "PHOTOGRAPHY", "PRODUCTIVITY", "SHOPPING", "SOCIAL", "SPORTS", "TOOLS", "TRAVEL_AND_LOCAL", "VIDEO_PLAYERS", "ANDROID_WEAR", "WATCH_FACE", "WEATHER", "FAMILY"]], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "store_device": NotRequired[Literal["phone", "tablet", "tv", "chromebook", "watch", "car"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlaySearchParams: TypeAlias = Union[GooglePlayJsonSearchParams, GooglePlayTextSearchParams] + +GooglePlayBooksJsonSearchParams = TypedDict( + "GooglePlayBooksJsonSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "books_category": NotRequired[str], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_books"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "price": NotRequired[_Number], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayBooksTextSearchParams = TypedDict( + "GooglePlayBooksTextSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "books_category": NotRequired[str], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_books"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "price": NotRequired[_Number], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayBooksSearchParams: TypeAlias = Union[GooglePlayBooksJsonSearchParams, GooglePlayBooksTextSearchParams] + +GooglePlayGamesJsonSearchParams = TypedDict( + "GooglePlayGamesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_games"]], + "games_category": NotRequired[Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "store_device": NotRequired[Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayGamesTextSearchParams = TypedDict( + "GooglePlayGamesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_games"]], + "games_category": NotRequired[Literal["GAME", "GAME_ACTION", "GAME_ADVENTURE", "GAME_ARCADE", "GAME_BOARD", "GAME_CARD", "GAME_CASINO", "GAME_CASUAL", "GAME_EDUCATIONAL", "GAME_MUSIC", "GAME_PUZZLE", "GAME_RACING", "GAME_ROLE_PLAYING", "GAME_SIMULATION", "GAME_SPORTS", "GAME_STRATEGY", "GAME_TRIVIA", "GAME_WORD"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "store_device": NotRequired[Literal["phone", "windows", "tablet", "tv", "chromebook", "watch"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayGamesSearchParams: TypeAlias = Union[GooglePlayGamesJsonSearchParams, GooglePlayGamesTextSearchParams] + +GooglePlayMoviesJsonSearchParams = TypedDict( + "GooglePlayMoviesJsonSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_movies"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "movies_category": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayMoviesTextSearchParams = TypedDict( + "GooglePlayMoviesTextSearchParams", + { + "age": NotRequired[Literal["AGE_RANGE1", "AGE_RANGE2", "AGE_RANGE3"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "chart": NotRequired[_Scalar], + "engine": Required[Literal["google_play_movies"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "movies_category": NotRequired[_Number], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "section_page_token": NotRequired[_Scalar], + "see_more_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayMoviesSearchParams: TypeAlias = Union[GooglePlayMoviesJsonSearchParams, GooglePlayMoviesTextSearchParams] + +GooglePlayProductJsonSearchParams = TypedDict( + "GooglePlayProductJsonSearchParams", + { + "all_reviews": NotRequired[_Flag], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_play_product"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "platform": NotRequired[Literal["phone", "tablet", "watch", "chromebook", "tv", "car"]], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "season_id": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "store": NotRequired[Literal["apps", "movies", "tv", "books", "audiobooks"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayProductTextSearchParams = TypedDict( + "GooglePlayProductTextSearchParams", + { + "all_reviews": NotRequired[_Flag], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_play_product"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "platform": NotRequired[Literal["phone", "tablet", "watch", "chromebook", "tv", "car"]], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "season_id": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "store": NotRequired[Literal["apps", "movies", "tv", "books", "audiobooks"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GooglePlayProductSearchParams: TypeAlias = Union[GooglePlayProductJsonSearchParams, GooglePlayProductTextSearchParams] + +GoogleProductJsonSearchParams = TypedDict( + "GoogleProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_product"]], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offer_view": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_token": NotRequired[_Scalar], + "product_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleProductTextSearchParams = TypedDict( + "GoogleProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_product"]], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offer_view": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_token": NotRequired[_Scalar], + "product_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleProductSearchParams: TypeAlias = Union[GoogleProductJsonSearchParams, GoogleProductTextSearchParams] + +GoogleRelatedQuestionsJsonSearchParams = TypedDict( + "GoogleRelatedQuestionsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_related_questions"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleRelatedQuestionsTextSearchParams = TypedDict( + "GoogleRelatedQuestionsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_related_questions"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleRelatedQuestionsSearchParams: TypeAlias = Union[GoogleRelatedQuestionsJsonSearchParams, GoogleRelatedQuestionsTextSearchParams] + +GoogleReverseImageJsonSearchParams = TypedDict( + "GoogleReverseImageJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_reverse_image"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleReverseImageTextSearchParams = TypedDict( + "GoogleReverseImageTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_reverse_image"]], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "image_url": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleReverseImageSearchParams: TypeAlias = Union[GoogleReverseImageJsonSearchParams, GoogleReverseImageTextSearchParams] + +GoogleScholarJsonSearchParams = TypedDict( + "GoogleScholarJsonSearchParams", + { + "api_key": NotRequired[str], + "as_rr": NotRequired[_Flag], + "as_sdt": NotRequired[_Scalar], + "as_vis": NotRequired[_Flag], + "as_yhi": NotRequired[_Number], + "as_ylo": NotRequired[_Number], + "async": NotRequired[_Flag], + "cites": NotRequired[_Scalar], + "cluster": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar"]], + "filter": NotRequired[_Flag], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "lr": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "scisbd": NotRequired[_Number], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarTextSearchParams = TypedDict( + "GoogleScholarTextSearchParams", + { + "api_key": NotRequired[str], + "as_rr": NotRequired[_Flag], + "as_sdt": NotRequired[_Scalar], + "as_vis": NotRequired[_Flag], + "as_yhi": NotRequired[_Number], + "as_ylo": NotRequired[_Number], + "async": NotRequired[_Flag], + "cites": NotRequired[_Scalar], + "cluster": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar"]], + "filter": NotRequired[_Flag], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "lr": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "scisbd": NotRequired[_Number], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarSearchParams: TypeAlias = Union[GoogleScholarJsonSearchParams, GoogleScholarTextSearchParams] + +GoogleScholarAuthorJsonSearchParams = TypedDict( + "GoogleScholarAuthorJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "author_id": NotRequired[_Scalar], + "citation_id": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar_author"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "sort": NotRequired[Literal["title", "pubdate"]], + "start": NotRequired[_Number], + "view_op": NotRequired[Literal["view_citation", "list_colleagues"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarAuthorTextSearchParams = TypedDict( + "GoogleScholarAuthorTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "author_id": NotRequired[_Scalar], + "citation_id": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar_author"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "sort": NotRequired[Literal["title", "pubdate"]], + "start": NotRequired[_Number], + "view_op": NotRequired[Literal["view_citation", "list_colleagues"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarAuthorSearchParams: TypeAlias = Union[GoogleScholarAuthorJsonSearchParams, GoogleScholarAuthorTextSearchParams] + +GoogleScholarCaseLawJsonSearchParams = TypedDict( + "GoogleScholarCaseLawJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "case_id": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar_case_law"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarCaseLawTextSearchParams = TypedDict( + "GoogleScholarCaseLawTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "case_id": NotRequired[_Scalar], + "engine": Required[Literal["google_scholar_case_law"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarCaseLawSearchParams: TypeAlias = Union[GoogleScholarCaseLawJsonSearchParams, GoogleScholarCaseLawTextSearchParams] + +GoogleScholarCiteJsonSearchParams = TypedDict( + "GoogleScholarCiteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_scholar_cite"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarCiteTextSearchParams = TypedDict( + "GoogleScholarCiteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_scholar_cite"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleScholarCiteSearchParams: TypeAlias = Union[GoogleScholarCiteJsonSearchParams, GoogleScholarCiteTextSearchParams] + +GoogleShoppingJsonSearchParams = TypedDict( + "GoogleShoppingJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_shopping"]], + "free_shipping": NotRequired[_Flag], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "on_sale": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "shoprs": NotRequired[_Scalar], + "small_business": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingTextSearchParams = TypedDict( + "GoogleShoppingTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_shopping"]], + "free_shipping": NotRequired[_Flag], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "on_sale": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "shoprs": NotRequired[_Scalar], + "small_business": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingSearchParams: TypeAlias = Union[GoogleShoppingJsonSearchParams, GoogleShoppingTextSearchParams] + +GoogleShoppingFiltersJsonSearchParams = TypedDict( + "GoogleShoppingFiltersJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_shopping_filters"]], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "shoprs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingFiltersTextSearchParams = TypedDict( + "GoogleShoppingFiltersTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_shopping_filters"]], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "shoprs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingFiltersSearchParams: TypeAlias = Union[GoogleShoppingFiltersJsonSearchParams, GoogleShoppingFiltersTextSearchParams] + +GoogleShoppingLightJsonSearchParams = TypedDict( + "GoogleShoppingLightJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_shopping_light"]], + "free_shipping": NotRequired[_Flag], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "on_sale": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "shoprs": NotRequired[_Scalar], + "small_business": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingLightTextSearchParams = TypedDict( + "GoogleShoppingLightTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_shopping_light"]], + "free_shipping": NotRequired[_Flag], + "gl": NotRequired[Literal["ai", "ar", "aw", "au", "at", "be", "bm", "br", "io", "ca", "ky", "cl", "cx", "cc", "co", "cz", "dk", "fk", "fi", "fr", "gf", "pf", "tf", "de", "gr", "gp", "hm", "hk", "hu", "in", "id", "ie", "il", "it", "jp", "kr", "my", "mq", "yt", "mx", "ms", "nl", "nc", "nz", "nf", "no", "ph", "pl", "pt", "re", "ro", "ru", "pm", "sa", "sg", "sk", "za", "gs", "es", "se", "ch", "tw", "th", "tk", "tr", "tc", "ua", "ae", "uk", "gb", "us", "vn", "vg", "wf"]], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "on_sale": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "shoprs": NotRequired[_Scalar], + "small_business": NotRequired[_Flag], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShoppingLightSearchParams: TypeAlias = Union[GoogleShoppingLightJsonSearchParams, GoogleShoppingLightTextSearchParams] + +GoogleShortVideosJsonSearchParams = TypedDict( + "GoogleShortVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_short_videos"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShortVideosTextSearchParams = TypedDict( + "GoogleShortVideosTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_short_videos"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleShortVideosSearchParams: TypeAlias = Union[GoogleShortVideosJsonSearchParams, GoogleShortVideosTextSearchParams] + +GoogleSportsJsonSearchParams = TypedDict( + "GoogleSportsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_sports"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "moa": NotRequired[_Scalar], + "mob": NotRequired[_Scalar], + "mpd": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "season_kgmid": NotRequired[_Scalar], + "sp": NotRequired[Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"]], + "tab": NotRequired[Literal["gm", "sn", "pl", "br", "st", "rn", "ov"]], + "type": NotRequired[Literal["game", "league", "team"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleSportsTextSearchParams = TypedDict( + "GoogleSportsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_sports"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "kgmid": NotRequired[_Scalar], + "moa": NotRequired[_Scalar], + "mob": NotRequired[_Scalar], + "mpd": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "season_kgmid": NotRequired[_Scalar], + "sp": NotRequired[Literal["ft", "bs", "bb", "cr", "af", "ih", "rg"]], + "tab": NotRequired[Literal["gm", "sn", "pl", "br", "st", "rn", "ov"]], + "type": NotRequired[Literal["game", "league", "team"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleSportsSearchParams: TypeAlias = Union[GoogleSportsJsonSearchParams, GoogleSportsTextSearchParams] + +GoogleTranslateJsonSearchParams = TypedDict( + "GoogleTranslateJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_translate"]], + "from": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "text": NotRequired[_Scalar], + "to": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTranslateTextSearchParams = TypedDict( + "GoogleTranslateTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_translate"]], + "from": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "text": NotRequired[_Scalar], + "to": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTranslateSearchParams: TypeAlias = Union[GoogleTranslateJsonSearchParams, GoogleTranslateTextSearchParams] + +GoogleTravelExploreJsonSearchParams = TypedDict( + "GoogleTravelExploreJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_area_id": NotRequired[_Scalar], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "bags": NotRequired[_Number], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_travel_explore"]], + "exclude_airlines": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "interest": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "month": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "output": NotRequired[Literal["json"]], + "return_date": NotRequired[_Scalar], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "travel_duration": NotRequired[_Number], + "travel_mode": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTravelExploreTextSearchParams = TypedDict( + "GoogleTravelExploreTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "arrival_area_id": NotRequired[_Scalar], + "arrival_id": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "bags": NotRequired[_Number], + "children": NotRequired[_Number], + "currency": NotRequired[Literal["ALL", "DZD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BYN", "BMD", "BAM", "BRL", "GBP", "BGN", "XPF", "CAD", "CLP", "CNY", "COP", "CRC", "CUP", "CZK", "DKK", "DOP", "EGP", "EUR", "GEL", "HKD", "HUF", "ISK", "INR", "IDR", "IRR", "ILS", "JMD", "JPY", "JOD", "KZT", "KWD", "LBP", "MKD", "MYR", "MXN", "MDL", "MAD", "TWD", "NZD", "NOK", "OMR", "PKR", "PAB", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "SAR", "RSD", "SGD", "ZAR", "KRW", "SEK", "CHF", "THB", "TRY", "USD", "UAH", "AED", "VND"]], + "departure_id": NotRequired[_Scalar], + "engine": Required[Literal["google_travel_explore"]], + "exclude_airlines": NotRequired[_Scalar], + "gl": NotRequired[str], + "hl": NotRequired[str], + "include_airlines": NotRequired[_Scalar], + "infants_in_seat": NotRequired[_Number], + "infants_on_lap": NotRequired[_Number], + "interest": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "max_duration": NotRequired[_Number], + "max_price": NotRequired[_Number], + "month": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "outbound_date": NotRequired[_Scalar], + "output": Required[Literal["html", "md"]], + "return_date": NotRequired[_Scalar], + "stops": NotRequired[_Number], + "travel_class": NotRequired[_Number], + "travel_duration": NotRequired[_Number], + "travel_mode": NotRequired[_Number], + "type": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTravelExploreSearchParams: TypeAlias = Union[GoogleTravelExploreJsonSearchParams, GoogleTravelExploreTextSearchParams] + +GoogleTrendsJsonSearchParams = TypedDict( + "GoogleTrendsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat": NotRequired[_Number], + "csv": NotRequired[_Flag], + "data_type": NotRequired[Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"]], + "date": NotRequired[_Scalar], + "engine": Required[Literal["google_trends"]], + "geo": NotRequired[_Scalar], + "gprop": NotRequired[Literal["", "images", "news", "froogle", "youtube"]], + "hl": NotRequired[str], + "include_low_search_volume": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "region": NotRequired[Literal["COUNTRY", "REGION", "DMA", "CITY"]], + "tz": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsTextSearchParams = TypedDict( + "GoogleTrendsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat": NotRequired[_Number], + "csv": NotRequired[_Flag], + "data_type": NotRequired[Literal["TIMESERIES", "GEO_MAP", "GEO_MAP_0", "RELATED_TOPICS", "RELATED_QUERIES"]], + "date": NotRequired[_Scalar], + "engine": Required[Literal["google_trends"]], + "geo": NotRequired[_Scalar], + "gprop": NotRequired[Literal["", "images", "news", "froogle", "youtube"]], + "hl": NotRequired[str], + "include_low_search_volume": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "region": NotRequired[Literal["COUNTRY", "REGION", "DMA", "CITY"]], + "tz": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsSearchParams: TypeAlias = Union[GoogleTrendsJsonSearchParams, GoogleTrendsTextSearchParams] + +GoogleTrendsAutocompleteJsonSearchParams = TypedDict( + "GoogleTrendsAutocompleteJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_trends_autocomplete"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsAutocompleteTextSearchParams = TypedDict( + "GoogleTrendsAutocompleteTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_trends_autocomplete"]], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsAutocompleteSearchParams: TypeAlias = Union[GoogleTrendsAutocompleteJsonSearchParams, GoogleTrendsAutocompleteTextSearchParams] + +GoogleTrendsNewsJsonSearchParams = TypedDict( + "GoogleTrendsNewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_trends_news"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsNewsTextSearchParams = TypedDict( + "GoogleTrendsNewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["google_trends_news"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsNewsSearchParams: TypeAlias = Union[GoogleTrendsNewsJsonSearchParams, GoogleTrendsNewsTextSearchParams] + +GoogleTrendsTrendingNowJsonSearchParams = TypedDict( + "GoogleTrendsTrendingNowJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat": NotRequired[Literal["all", "b", "e", "m", "t", "s", "h"]], + "category_id": NotRequired[_Number], + "date": NotRequired[_Scalar], + "engine": Required[Literal["google_trends_trending_now"]], + "frequency": NotRequired[Literal["daily", "realtime"]], + "geo": NotRequired[_Number], + "hl": NotRequired[str], + "hours": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "only_active": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsTrendingNowTextSearchParams = TypedDict( + "GoogleTrendsTrendingNowTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat": NotRequired[Literal["all", "b", "e", "m", "t", "s", "h"]], + "category_id": NotRequired[_Number], + "date": NotRequired[_Scalar], + "engine": Required[Literal["google_trends_trending_now"]], + "frequency": NotRequired[Literal["daily", "realtime"]], + "geo": NotRequired[_Number], + "hl": NotRequired[str], + "hours": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "only_active": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleTrendsTrendingNowSearchParams: TypeAlias = Union[GoogleTrendsTrendingNowJsonSearchParams, GoogleTrendsTrendingNowTextSearchParams] + +GoogleVideosJsonSearchParams = TypedDict( + "GoogleVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_videos"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleVideosTextSearchParams = TypedDict( + "GoogleVideosTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_videos"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleVideosSearchParams: TypeAlias = Union[GoogleVideosJsonSearchParams, GoogleVideosTextSearchParams] + +GoogleVideosLightJsonSearchParams = TypedDict( + "GoogleVideosLightJsonSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_videos_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleVideosLightTextSearchParams = TypedDict( + "GoogleVideosLightTextSearchParams", + { + "api_key": NotRequired[str], + "as_dt": NotRequired[_Scalar], + "as_epq": NotRequired[_Scalar], + "as_eq": NotRequired[_Scalar], + "as_lq": NotRequired[_Scalar], + "as_nhi": NotRequired[_Scalar], + "as_nlo": NotRequired[_Scalar], + "as_oq": NotRequired[_Scalar], + "as_q": NotRequired[_Scalar], + "as_qdr": NotRequired[_Scalar], + "as_rq": NotRequired[_Scalar], + "as_sitesearch": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["google_videos_light"]], + "filter": NotRequired[_Flag], + "gl": NotRequired[str], + "google_domain": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "location": NotRequired[str], + "lr": NotRequired[_Scalar], + "nfpr": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "tbs": NotRequired[_Scalar], + "uule": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +GoogleVideosLightSearchParams: TypeAlias = Union[GoogleVideosLightJsonSearchParams, GoogleVideosLightTextSearchParams] + +HomeDepotJsonSearchParams = TypedDict( + "HomeDepotJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["us", "ca"]], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["home_depot"]], + "filter": NotRequired[_Scalar], + "hd_filter_tokens": NotRequired[_Scalar], + "hd_sort": NotRequired[Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"]], + "json_restrictor": NotRequired[_Scalar], + "lowerbound": NotRequired[_Number], + "minmax": NotRequired[_Scalar], + "nao": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "pagesize": NotRequired[_Scalar], + "ps": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"]], + "store": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "upperbound": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotTextSearchParams = TypedDict( + "HomeDepotTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "country": NotRequired[Literal["us", "ca"]], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["home_depot"]], + "filter": NotRequired[_Scalar], + "hd_filter_tokens": NotRequired[_Scalar], + "hd_sort": NotRequired[Literal["top_sellers", "price_low_to_high", "price_high_to_low", "top_rated", "best_match"]], + "json_restrictor": NotRequired[_Scalar], + "lowerbound": NotRequired[_Number], + "minmax": NotRequired[_Scalar], + "nao": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "pagesize": NotRequired[_Scalar], + "ps": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["price-asc", "price-desc", "reviewAvgRating", "relevance"]], + "store": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "upperbound": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotSearchParams: TypeAlias = Union[HomeDepotJsonSearchParams, HomeDepotTextSearchParams] + +HomeDepotProductJsonSearchParams = TypedDict( + "HomeDepotProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["home_depot_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "store_sku": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotProductTextSearchParams = TypedDict( + "HomeDepotProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["home_depot_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "store_sku": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotProductSearchParams: TypeAlias = Union[HomeDepotProductJsonSearchParams, HomeDepotProductTextSearchParams] + +HomeDepotProductReviewsJsonSearchParams = TypedDict( + "HomeDepotProductReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["home_depot_product_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "pagesize": NotRequired[_Scalar], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"]], + "start": NotRequired[_Number], + "term": NotRequired[_Scalar], + "verified_purchases": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotProductReviewsTextSearchParams = TypedDict( + "HomeDepotProductReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["home_depot_product_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "pagesize": NotRequired[_Scalar], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["photoreview", "mosthelpfull", "oldest", "newest", "highestrating", "lowestrating"]], + "start": NotRequired[_Number], + "term": NotRequired[_Scalar], + "verified_purchases": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +HomeDepotProductReviewsSearchParams: TypeAlias = Union[HomeDepotProductReviewsJsonSearchParams, HomeDepotProductReviewsTextSearchParams] + +IndeedJobsJsonSearchParams = TypedDict( + "IndeedJobsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["indeed_jobs"]], + "fromage": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "jt": NotRequired[Literal["fulltime", "parttime", "contract", "temporary", "internship"]], + "l": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "sort": NotRequired[Literal["date"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +IndeedJobsTextSearchParams = TypedDict( + "IndeedJobsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["indeed_jobs"]], + "fromage": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "jt": NotRequired[Literal["fulltime", "parttime", "contract", "temporary", "internship"]], + "l": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "sort": NotRequired[Literal["date"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +IndeedJobsSearchParams: TypeAlias = Union[IndeedJobsJsonSearchParams, IndeedJobsTextSearchParams] + +InstagramPopularJsonSearchParams = TypedDict( + "InstagramPopularJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["instagram_popular"]], + "json_restrictor": NotRequired[_Scalar], + "keyword": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +InstagramPopularTextSearchParams = TypedDict( + "InstagramPopularTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["instagram_popular"]], + "json_restrictor": NotRequired[_Scalar], + "keyword": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +InstagramPopularSearchParams: TypeAlias = Union[InstagramPopularJsonSearchParams, InstagramPopularTextSearchParams] + +InstagramProfileJsonSearchParams = TypedDict( + "InstagramProfileJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["instagram_profile"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "profile_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +InstagramProfileTextSearchParams = TypedDict( + "InstagramProfileTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["instagram_profile"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "profile_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +InstagramProfileSearchParams: TypeAlias = Union[InstagramProfileJsonSearchParams, InstagramProfileTextSearchParams] + +MetaAdLibraryJsonSearchParams = TypedDict( + "MetaAdLibraryJsonSearchParams", + { + "active_status": NotRequired[Literal["active", "inactive", "all"]], + "ad_type": NotRequired[Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "content_languages": NotRequired[_Scalar], + "country": NotRequired[str], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["meta_ad_library"]], + "json_restrictor": NotRequired[_Scalar], + "media_type": NotRequired[Literal["all", "image", "meme", "image_and_meme", "video", "none"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_id": NotRequired[_Scalar], + "publisher_platforms": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "search_type": NotRequired[Literal["keyword_unordered", "keyword_exact_phrase"]], + "sort_by": NotRequired[Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"]], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +MetaAdLibraryTextSearchParams = TypedDict( + "MetaAdLibraryTextSearchParams", + { + "active_status": NotRequired[Literal["active", "inactive", "all"]], + "ad_type": NotRequired[Literal["all", "political_and_issue_ads", "housing_ads", "employment_ads", "financial_products_and_services_ads"]], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "content_languages": NotRequired[_Scalar], + "country": NotRequired[str], + "end_date": NotRequired[_Scalar], + "engine": Required[Literal["meta_ad_library"]], + "json_restrictor": NotRequired[_Scalar], + "media_type": NotRequired[Literal["all", "image", "meme", "image_and_meme", "video", "none"]], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_id": NotRequired[_Scalar], + "publisher_platforms": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "search_type": NotRequired[Literal["keyword_unordered", "keyword_exact_phrase"]], + "sort_by": NotRequired[Literal["most_recent", "impressions_high_to_low", "impressions_low_to_high"]], + "start_date": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +MetaAdLibrarySearchParams: TypeAlias = Union[MetaAdLibraryJsonSearchParams, MetaAdLibraryTextSearchParams] + +NapaJsonSearchParams = TypedDict( + "NapaJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["napa"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"]], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NapaTextSearchParams = TypedDict( + "NapaTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["napa"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["relevance", "price_low_to_high", "price_high_to_low", "product_description", "line_abbreviation", "part_number"]], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NapaSearchParams: TypeAlias = Union[NapaJsonSearchParams, NapaTextSearchParams] + +NaverJsonSearchParams = TypedDict( + "NaverJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["naver"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "period": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "where": NotRequired[Literal["nexearch", "web", "news", "video", "image"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverTextSearchParams = TypedDict( + "NaverTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["naver"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "period": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[_Number], + "start": NotRequired[_Number], + "where": NotRequired[Literal["nexearch", "web", "news", "video", "image"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverSearchParams: TypeAlias = Union[NaverJsonSearchParams, NaverTextSearchParams] + +NaverAiModeJsonSearchParams = TypedDict( + "NaverAiModeJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "continuable": NotRequired[_Flag], + "engine": Required[Literal["naver_ai_mode"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "query": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverAiModeTextSearchParams = TypedDict( + "NaverAiModeTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "continuable": NotRequired[_Flag], + "engine": Required[Literal["naver_ai_mode"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "query": NotRequired[_Scalar], + "subsequent_request_token": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverAiModeSearchParams: TypeAlias = Union[NaverAiModeJsonSearchParams, NaverAiModeTextSearchParams] + +NaverAiOverviewJsonSearchParams = TypedDict( + "NaverAiOverviewJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["naver_ai_overview"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page_token": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverAiOverviewTextSearchParams = TypedDict( + "NaverAiOverviewTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["naver_ai_overview"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page_token": NotRequired[_Scalar], + "query": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverAiOverviewSearchParams: TypeAlias = Union[NaverAiOverviewJsonSearchParams, NaverAiOverviewTextSearchParams] + +NaverMapsJsonSearchParams = TypedDict( + "NaverMapsJsonSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bookable": NotRequired[_Flag], + "center": NotRequired[_Scalar], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "coupon": NotRequired[_Flag], + "engine": Required[Literal["naver_maps"]], + "json_restrictor": NotRequired[_Scalar], + "naver_pay": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "open_state": NotRequired[Literal["now"]], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["distance"]], + "wheelchair_accessible": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverMapsTextSearchParams = TypedDict( + "NaverMapsTextSearchParams", + { + "adults": NotRequired[_Number], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "bookable": NotRequired[_Flag], + "center": NotRequired[_Scalar], + "check_in_date": NotRequired[_Scalar], + "check_out_date": NotRequired[_Scalar], + "children": NotRequired[_Number], + "coupon": NotRequired[_Flag], + "engine": Required[Literal["naver_maps"]], + "json_restrictor": NotRequired[_Scalar], + "naver_pay": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "open_state": NotRequired[Literal["now"]], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "query": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["distance"]], + "wheelchair_accessible": NotRequired[_Flag], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +NaverMapsSearchParams: TypeAlias = Union[NaverMapsJsonSearchParams, NaverMapsTextSearchParams] + +OpenTableReviewsJsonSearchParams = TypedDict( + "OpenTableReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["open_table_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "open_table_domain": NotRequired[Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"]], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "rid": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +OpenTableReviewsTextSearchParams = TypedDict( + "OpenTableReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["open_table_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "open_table_domain": NotRequired[Literal["opentable.com", "opentable.jp", "opentable.de", "opentable.es", "opentable.ca", "opentable.hk", "opentable.ie", "opentable.sg", "opentable.nl", "opentable.com.mx", "opentable.co.uk", "opentable.com.au", "opentable.ae", "opentable.co.th", "opentable.it", "opentable.com.tw", "opentable.fr"]], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "rid": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +OpenTableReviewsSearchParams: TypeAlias = Union[OpenTableReviewsJsonSearchParams, OpenTableReviewsTextSearchParams] + +PinterestJsonSearchParams = TypedDict( + "PinterestJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["pinterest"]], + "json_restrictor": NotRequired[_Scalar], + "less_ai": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "type": NotRequired[Literal["pins", "videos", "boards", "profiles", "products"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +PinterestTextSearchParams = TypedDict( + "PinterestTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["pinterest"]], + "json_restrictor": NotRequired[_Scalar], + "less_ai": NotRequired[_Flag], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "type": NotRequired[Literal["pins", "videos", "boards", "profiles", "products"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +PinterestSearchParams: TypeAlias = Union[PinterestJsonSearchParams, PinterestTextSearchParams] + +SearchIndexJsonSearchParams = TypedDict( + "SearchIndexJsonSearchParams", + { + "api_key": NotRequired[str], + "as_yhi": NotRequired[_Scalar], + "as_ylo": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "engine": Required[Literal["search_index"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "ll": NotRequired[_Scalar], + "mode": NotRequired[Literal["deep"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "product_source": NotRequired[Literal["google", "amazon", "walmart", "ebay", "home_depot"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "type": NotRequired[Literal["web", "place", "product", "video", "publication"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +SearchIndexTextSearchParams = TypedDict( + "SearchIndexTextSearchParams", + { + "api_key": NotRequired[str], + "as_yhi": NotRequired[_Scalar], + "as_ylo": NotRequired[_Scalar], + "async": NotRequired[_Flag], + "engine": Required[Literal["search_index"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "ll": NotRequired[_Scalar], + "mode": NotRequired[Literal["deep"]], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "product_source": NotRequired[Literal["google", "amazon", "walmart", "ebay", "home_depot"]], + "q": NotRequired[_Scalar], + "radius": NotRequired[_Number], + "safe": NotRequired[Literal["active", "off"]], + "start": NotRequired[_Number], + "type": NotRequired[Literal["web", "place", "product", "video", "publication"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +SearchIndexSearchParams: TypeAlias = Union[SearchIndexJsonSearchParams, SearchIndexTextSearchParams] + +TargetJsonSearchParams = TypedDict( + "TargetJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["target"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"]], + "spelling": NotRequired[_Flag], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TargetTextSearchParams = TypedDict( + "TargetTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "delivery_zip": NotRequired[_Scalar], + "engine": Required[Literal["target"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort": NotRequired[Literal["relevance", "featured", "price_low", "price_high", "rating_high", "best_seller", "newest"]], + "spelling": NotRequired[_Flag], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TargetSearchParams: TypeAlias = Union[TargetJsonSearchParams, TargetTextSearchParams] + +TiktokDiscoverJsonSearchParams = TypedDict( + "TiktokDiscoverJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tiktok_discover"]], + "gl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "session_token": NotRequired[_Scalar], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TiktokDiscoverTextSearchParams = TypedDict( + "TiktokDiscoverTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tiktok_discover"]], + "gl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "session_token": NotRequired[_Scalar], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TiktokDiscoverSearchParams: TypeAlias = Union[TiktokDiscoverJsonSearchParams, TiktokDiscoverTextSearchParams] + +TiktokShopJsonSearchParams = TypedDict( + "TiktokShopJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "color_id": NotRequired[_Scalar], + "deals": NotRequired[_Flag], + "engine": Required[Literal["tiktok_shop"]], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort": NotRequired[Literal["relevance", "best_seller", "newest"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TiktokShopTextSearchParams = TypedDict( + "TiktokShopTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Scalar], + "color_id": NotRequired[_Scalar], + "deals": NotRequired[_Flag], + "engine": Required[Literal["tiktok_shop"]], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort": NotRequired[Literal["relevance", "best_seller", "newest"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TiktokShopSearchParams: TypeAlias = Union[TiktokShopJsonSearchParams, TiktokShopTextSearchParams] + +TraderJoesJsonSearchParams = TypedDict( + "TraderJoesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Number], + "characteristics": NotRequired[_Scalar], + "engine": Required[Literal["trader_joes"]], + "json_restrictor": NotRequired[_Scalar], + "new_products": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["price_low_to_high", "price_high_to_low", "popularity"]], + "store_id": NotRequired[_Number], + "tags": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TraderJoesTextSearchParams = TypedDict( + "TraderJoesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_id": NotRequired[_Number], + "characteristics": NotRequired[_Scalar], + "engine": Required[Literal["trader_joes"]], + "json_restrictor": NotRequired[_Scalar], + "new_products": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "q": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["price_low_to_high", "price_high_to_low", "popularity"]], + "store_id": NotRequired[_Number], + "tags": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TraderJoesSearchParams: TypeAlias = Union[TraderJoesJsonSearchParams, TraderJoesTextSearchParams] + +TraderJoesProductJsonSearchParams = TypedDict( + "TraderJoesProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["trader_joes_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TraderJoesProductTextSearchParams = TypedDict( + "TraderJoesProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["trader_joes_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TraderJoesProductSearchParams: TypeAlias = Union[TraderJoesProductJsonSearchParams, TraderJoesProductTextSearchParams] + +TripadvisorJsonSearchParams = TypedDict( + "TripadvisorJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "limit": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "q": NotRequired[_Scalar], + "ssrc": NotRequired[Literal["a", "r", "A", "h", "g", "v", "f"]], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorTextSearchParams = TypedDict( + "TripadvisorTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor"]], + "json_restrictor": NotRequired[_Scalar], + "lat": NotRequired[_Number], + "limit": NotRequired[_Number], + "lon": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "q": NotRequired[_Scalar], + "ssrc": NotRequired[Literal["a", "r", "A", "h", "g", "v", "f"]], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorSearchParams: TypeAlias = Union[TripadvisorJsonSearchParams, TripadvisorTextSearchParams] + +TripadvisorPlaceJsonSearchParams = TypedDict( + "TripadvisorPlaceJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor_place"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorPlaceTextSearchParams = TypedDict( + "TripadvisorPlaceTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor_place"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorPlaceSearchParams: TypeAlias = Union[TripadvisorPlaceJsonSearchParams, TripadvisorPlaceTextSearchParams] + +TripadvisorReviewsJsonSearchParams = TypedDict( + "TripadvisorReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"]], + "limit": NotRequired[_Number], + "month": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["most_recent", "detailed_review"]], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "type_of_visit": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorReviewsTextSearchParams = TypedDict( + "TripadvisorReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["tripadvisor_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "language": NotRequired[Literal["ar", "cs", "da", "de", "el", "en", "es", "fi", "fr", "he", "hu", "id", "it", "ja", "ko", "nb", "nl", "pl", "pt", "ru", "sk", "sr", "sv", "th", "tr", "vi", "zh"]], + "limit": NotRequired[_Number], + "month": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "offset": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sort_by": NotRequired[Literal["most_recent", "detailed_review"]], + "tripadvisor_domain": NotRequired[Literal["www.tripadvisor.com", "ar.tripadvisor.com", "www.tripadvisor.com.ar", "www.tripadvisor.com.au", "www.tripadvisor.at", "www.tripadvisor.be", "fr.tripadvisor.be", "www.tripadvisor.com.br", "www.tripadvisor.ca", "fr.tripadvisor.ca", "www.tripadvisor.cl", "cn.tripadvisor.com", "www.tripadvisor.co", "www.tripadvisor.com.pe", "www.tripadvisor.dk", "www.tripadvisor.com.eg", "www.tripadvisor.fr", "www.tripadvisor.de", "www.tripadvisor.com.gr", "www.tripadvisor.com.hk", "en.tripadvisor.com.hk", "www.tripadvisor.in", "www.tripadvisor.co.id", "www.tripadvisor.ie", "www.tripadvisor.co.il", "www.tripadvisor.it", "www.tripadvisor.jp", "www.tripadvisor.co.kr", "www.tripadvisor.com.my", "www.tripadvisor.com.mx", "www.tripadvisor.nl", "www.tripadvisor.co.nz", "no.tripadvisor.com", "www.tripadvisor.com.ph", "www.tripadvisor.pt", "www.tripadvisor.ru", "www.tripadvisor.com.sg", "www.tripadvisor.co.za", "www.tripadvisor.es", "www.tripadvisor.se", "fr.tripadvisor.ch", "www.tripadvisor.ch", "it.tripadvisor.ch", "www.tripadvisor.com.tw", "th.tripadvisor.com", "www.tripadvisor.com.tr", "www.tripadvisor.co.uk", "www.tripadvisor.com.ve", "www.tripadvisor.com.vn"]], + "type_of_visit": NotRequired[str], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +TripadvisorReviewsSearchParams: TypeAlias = Union[TripadvisorReviewsJsonSearchParams, TripadvisorReviewsTextSearchParams] + +WalmartJsonSearchParams = TypedDict( + "WalmartJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat_id": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["walmart"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "nd_en": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "query": NotRequired[_Scalar], + "soft_sort": NotRequired[_Flag], + "sort": NotRequired[Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"]], + "spelling": NotRequired[_Flag], + "store_id": NotRequired[_Scalar], + "walmart_domain": NotRequired[Literal["walmart.com", "walmart.com.mx"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartTextSearchParams = TypedDict( + "WalmartTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "cat_id": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["walmart"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "max_price": NotRequired[_Number], + "min_price": NotRequired[_Number], + "nd_en": NotRequired[_Flag], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "query": NotRequired[_Scalar], + "soft_sort": NotRequired[_Flag], + "sort": NotRequired[Literal["price_low", "price_high", "best_seller", "best_match", "rating_high"]], + "spelling": NotRequired[_Flag], + "store_id": NotRequired[_Scalar], + "walmart_domain": NotRequired[Literal["walmart.com", "walmart.com.mx"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartSearchParams: TypeAlias = Union[WalmartJsonSearchParams, WalmartTextSearchParams] + +WalmartProductJsonSearchParams = TypedDict( + "WalmartProductJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["walmart_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductTextSearchParams = TypedDict( + "WalmartProductTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["walmart_product"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductSearchParams: TypeAlias = Union[WalmartProductJsonSearchParams, WalmartProductTextSearchParams] + +WalmartProductReviewsJsonSearchParams = TypedDict( + "WalmartProductReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["walmart_product_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort": NotRequired[Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductReviewsTextSearchParams = TypedDict( + "WalmartProductReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["walmart_product_reviews"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "product_id": NotRequired[_Scalar], + "rating": NotRequired[_Number], + "sort": NotRequired[Literal["relevancy", "helpful", "submission-desc", "submission-asc", "rating-desc", "rating-asc"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductReviewsSearchParams: TypeAlias = Union[WalmartProductReviewsJsonSearchParams, WalmartProductReviewsTextSearchParams] + +WalmartProductSellersJsonSearchParams = TypedDict( + "WalmartProductSellersJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["walmart_product_sellers"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductSellersTextSearchParams = TypedDict( + "WalmartProductSellersTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["walmart_product_sellers"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "product_id": NotRequired[_Scalar], + "store_id": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartProductSellersSearchParams: TypeAlias = Union[WalmartProductSellersJsonSearchParams, WalmartProductSellersTextSearchParams] + +WalmartSellerJsonSearchParams = TypedDict( + "WalmartSellerJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "catalog_seller_id": NotRequired[_Scalar], + "engine": Required[Literal["walmart_seller"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "sort": NotRequired[Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartSellerTextSearchParams = TypedDict( + "WalmartSellerTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "catalog_seller_id": NotRequired[_Scalar], + "engine": Required[Literal["walmart_seller"]], + "facet": NotRequired[_Scalar], + "include_filters": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "sort": NotRequired[Literal["best_match", "price_low", "price_high", "best_seller", "rating_high", "new"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +WalmartSellerSearchParams: TypeAlias = Union[WalmartSellerJsonSearchParams, WalmartSellerTextSearchParams] + +YahooJsonSearchParams = TypedDict( + "YahooJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "d": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["yahoo"]], + "fr2": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Scalar], + "vc": NotRequired[str], + "vf": NotRequired[Literal["html", "pdf", "xls", "ppt", "doc", "txt"]], + "vl": NotRequired[Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"]], + "vm": NotRequired[Literal["r", "i", "p"]], + "vs": NotRequired[_Scalar], + "yahoo_domain": NotRequired[Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooTextSearchParams = TypedDict( + "YahooTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "d": NotRequired[_Scalar], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["yahoo"]], + "fr2": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Scalar], + "vc": NotRequired[str], + "vf": NotRequired[Literal["html", "pdf", "xls", "ppt", "doc", "txt"]], + "vl": NotRequired[Literal["lang_ar", "lang_bg", "lang_zh_chs", "lang_zh_cht", "lang_hr", "lang_cs", "lang_da", "lang_nl", "lang_en", "lang_et", "lang_fi", "lang_fr", "lang_de", "lang_el", "lang_he", "lang_hu", "lang_it", "lang_ja", "lang_ko", "lang_lv", "lang_lt", "lang_no", "lang_pl", "lang_pt", "lang_ro", "lang_ru", "lang_sk", "lang_sl", "lang_es", "lang_sv", "lang_th", "lang_tr"]], + "vm": NotRequired[Literal["r", "i", "p"]], + "vs": NotRequired[_Scalar], + "yahoo_domain": NotRequired[Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooSearchParams: TypeAlias = Union[YahooJsonSearchParams, YahooTextSearchParams] + +YahooImagesJsonSearchParams = TypedDict( + "YahooImagesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["yahoo_images"]], + "imga": NotRequired[Literal["square", "wide", "tall"]], + "imgc": NotRequired[Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"]], + "imgf": NotRequired[Literal["face", "portrait", "nonportrait"]], + "imgl": NotRequired[Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"]], + "imgsz": NotRequired[Literal["small", "medium", "large", "wallpaper"]], + "imgt": NotRequired[Literal["day", "week", "month", "year"]], + "imgty": NotRequired[Literal["photo", "clipart", "linedrawing", "gif", "transparent"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Scalar], + "yahoo_domain": NotRequired[Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooImagesTextSearchParams = TypedDict( + "YahooImagesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": Required[Literal["yahoo_images"]], + "imga": NotRequired[Literal["square", "wide", "tall"]], + "imgc": NotRequired[Literal["color", "bw", "red", "orange", "yellow", "green", "teal", "blue", "purple", "pink", "brown", "black", "gray", "white"]], + "imgf": NotRequired[Literal["face", "portrait", "nonportrait"]], + "imgl": NotRequired[Literal["cc", "pd", "fsu", "fsuc", "fmsu", "fmsuc"]], + "imgsz": NotRequired[Literal["small", "medium", "large", "wallpaper"]], + "imgt": NotRequired[Literal["day", "week", "month", "year"]], + "imgty": NotRequired[Literal["photo", "clipart", "linedrawing", "gif", "transparent"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Scalar], + "yahoo_domain": NotRequired[Literal["espanol", "fr", "br", "ca", "de", "es", "in", "id", "it", "malaysia", "nl", "no", "at", "ph", "qc", "ch", "sg", "fi", "se", "uk", "vn", "ru", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooImagesSearchParams: TypeAlias = Union[YahooImagesJsonSearchParams, YahooImagesTextSearchParams] + +YahooShoppingJsonSearchParams = TypedDict( + "YahooShoppingJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_attr_values": NotRequired[_Scalar], + "engine": Required[Literal["yahoo_shopping"]], + "json_restrictor": NotRequired[_Scalar], + "limit": NotRequired[_Number], + "max_price": NotRequired[_Scalar], + "merchants": NotRequired[_Scalar], + "min_price": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "order_by": NotRequired[Literal["ASC", "DESC"]], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Scalar], + "page": NotRequired[_Number], + "sort_by": NotRequired[Literal["price", "relevancy", "popularity", "discountPercentage"]], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooShoppingTextSearchParams = TypedDict( + "YahooShoppingTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "category_attr_values": NotRequired[_Scalar], + "engine": Required[Literal["yahoo_shopping"]], + "json_restrictor": NotRequired[_Scalar], + "limit": NotRequired[_Number], + "max_price": NotRequired[_Scalar], + "merchants": NotRequired[_Scalar], + "min_price": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "order_by": NotRequired[Literal["ASC", "DESC"]], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Scalar], + "page": NotRequired[_Number], + "sort_by": NotRequired[Literal["price", "relevancy", "popularity", "discountPercentage"]], + "start": NotRequired[_Number], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooShoppingSearchParams: TypeAlias = Union[YahooShoppingJsonSearchParams, YahooShoppingTextSearchParams] + +YahooTrendsJsonSearchParams = TypedDict( + "YahooTrendsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yahoo_trends"]], + "full_video_links": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooTrendsTextSearchParams = TypedDict( + "YahooTrendsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yahoo_trends"]], + "full_video_links": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooTrendsSearchParams: TypeAlias = Union[YahooTrendsJsonSearchParams, YahooTrendsTextSearchParams] + +YahooVideosJsonSearchParams = TypedDict( + "YahooVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "durs": NotRequired[Literal["short", "medium", "long"]], + "engine": Required[Literal["yahoo_videos"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Scalar], + "vage": NotRequired[Literal["day", "week", "month", "year"]], + "vres": NotRequired[Literal["360p", "480p", "720p", "1080p"]], + "vsite": NotRequired[Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"]], + "yahoo_domain": NotRequired[Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooVideosTextSearchParams = TypedDict( + "YahooVideosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "b": NotRequired[_Number], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "durs": NotRequired[Literal["short", "medium", "long"]], + "engine": Required[Literal["yahoo_videos"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Scalar], + "vage": NotRequired[Literal["day", "week", "month", "year"]], + "vres": NotRequired[Literal["360p", "480p", "720p", "1080p"]], + "vsite": NotRequired[Literal["youtube", "dailymotion", "vimeo", "mtv", "cbsnews", "foxnews", "cnn", "msn"]], + "yahoo_domain": NotRequired[Literal["espanol", "be", "fr", "br", "ca", "de", "es", "in", "id", "ie", "it", "malaysia", "nl", "no", "at", "ph", "pl", "qc", "ro", "ch", "sg", "za", "fi", "se", "tr", "uk", "vn", "gr", "ru", "ua", "il", "hk", "tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YahooVideosSearchParams: TypeAlias = Union[YahooVideosJsonSearchParams, YahooVideosTextSearchParams] + +YandexJsonSearchParams = TypedDict( + "YandexJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yandex"]], + "family_mode": NotRequired[_Number], + "fix_typo": NotRequired[Literal["false", "true"]], + "groups_on_page": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[Literal["ru", "en", "be", "kk", "tr", "uk"]], + "lr": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Number], + "period": NotRequired[Literal["all", "day", "last_two_weeks", "month"]], + "sort_mode": NotRequired[Literal["relevance", "time"]], + "text": NotRequired[_Scalar], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexTextSearchParams = TypedDict( + "YandexTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yandex"]], + "family_mode": NotRequired[_Number], + "fix_typo": NotRequired[Literal["false", "true"]], + "groups_on_page": NotRequired[_Number], + "json_restrictor": NotRequired[_Scalar], + "lang": NotRequired[Literal["ru", "en", "be", "kk", "tr", "uk"]], + "lr": NotRequired[_Number], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Number], + "period": NotRequired[Literal["all", "day", "last_two_weeks", "month"]], + "sort_mode": NotRequired[Literal["relevance", "time"]], + "text": NotRequired[_Scalar], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexSearchParams: TypeAlias = Union[YandexJsonSearchParams, YandexTextSearchParams] + +YandexImagesJsonSearchParams = TypedDict( + "YandexImagesJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "color": NotRequired[Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"]], + "crop": NotRequired[_Scalar], + "crop_id": NotRequired[_Number], + "engine": Required[Literal["yandex_images"]], + "family_mode": NotRequired[_Number], + "file_type": NotRequired[Literal["jpg", "png", "gifan"]], + "height": NotRequired[_Number], + "image_type": NotRequired[Literal["photo", "clipart", "lineart", "face", "demotivator"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "orientation": NotRequired[Literal["horizontal", "vertical", "square"]], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Number], + "recent": NotRequired[_Flag], + "site": NotRequired[_Scalar], + "tab": NotRequired[Literal["about", "similar"]], + "text": NotRequired[_Scalar], + "url": NotRequired[_Scalar], + "width": NotRequired[_Number], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexImagesTextSearchParams = TypedDict( + "YandexImagesTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "color": NotRequired[Literal["color", "gray", "red", "orange", "yellow", "cyan", "green", "blue", "violet", "white", "black"]], + "crop": NotRequired[_Scalar], + "crop_id": NotRequired[_Number], + "engine": Required[Literal["yandex_images"]], + "family_mode": NotRequired[_Number], + "file_type": NotRequired[Literal["jpg", "png", "gifan"]], + "height": NotRequired[_Number], + "image_type": NotRequired[Literal["photo", "clipart", "lineart", "face", "demotivator"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "orientation": NotRequired[Literal["horizontal", "vertical", "square"]], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Number], + "recent": NotRequired[_Flag], + "site": NotRequired[_Scalar], + "tab": NotRequired[Literal["about", "similar"]], + "text": NotRequired[_Scalar], + "url": NotRequired[_Scalar], + "width": NotRequired[_Number], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexImagesSearchParams: TypeAlias = Union[YandexImagesJsonSearchParams, YandexImagesTextSearchParams] + +YandexVideosJsonSearchParams = TypedDict( + "YandexVideosJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "duration": NotRequired[Literal["short", "medium", "long"]], + "engine": Required[Literal["yandex_videos"]], + "hd": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "p": NotRequired[_Number], + "text": NotRequired[_Scalar], + "within": NotRequired[_Number], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexVideosTextSearchParams = TypedDict( + "YandexVideosTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "duration": NotRequired[Literal["short", "medium", "long"]], + "engine": Required[Literal["yandex_videos"]], + "hd": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "p": NotRequired[_Number], + "text": NotRequired[_Scalar], + "within": NotRequired[_Number], + "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YandexVideosSearchParams: TypeAlias = Union[YandexVideosJsonSearchParams, YandexVideosTextSearchParams] + +YelpJsonSearchParams = TypedDict( + "YelpJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yelp"]], + "find_desc": NotRequired[_Scalar], + "find_loc": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "sortby": NotRequired[Literal["recommended", "rating", "review_count"]], + "start": NotRequired[_Number], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpTextSearchParams = TypedDict( + "YelpTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yelp"]], + "find_desc": NotRequired[_Scalar], + "find_loc": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "sortby": NotRequired[Literal["recommended", "rating", "review_count"]], + "start": NotRequired[_Number], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpSearchParams: TypeAlias = Union[YelpJsonSearchParams, YelpTextSearchParams] + +YelpPlaceJsonSearchParams = TypedDict( + "YelpPlaceJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "business_alert": NotRequired[_Flag], + "engine": Required[Literal["yelp_place"]], + "full_menu": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "menu_name": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpPlaceTextSearchParams = TypedDict( + "YelpPlaceTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "business_alert": NotRequired[_Flag], + "engine": Required[Literal["yelp_place"]], + "full_menu": NotRequired[_Flag], + "json_restrictor": NotRequired[_Scalar], + "menu_name": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpPlaceSearchParams: TypeAlias = Union[YelpPlaceJsonSearchParams, YelpPlaceTextSearchParams] + +YelpReviewsJsonSearchParams = TypedDict( + "YelpReviewsJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yelp_reviews"]], + "hl": NotRequired[Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "not_recommended": NotRequired[_Flag], + "not_recommended_start": NotRequired[_Number], + "num": NotRequired[_Number], + "output": NotRequired[Literal["json"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sortby": NotRequired[Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"]], + "start": NotRequired[_Number], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpReviewsTextSearchParams = TypedDict( + "YelpReviewsTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["yelp_reviews"]], + "hl": NotRequired[Literal["ms", "cs", "da", "de", "en", "es", "fil", "fr", "it", "nl", "nb", "pl", "pt", "fi", "sv", "tr", "ja", "zh"]], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "not_recommended": NotRequired[_Flag], + "not_recommended_start": NotRequired[_Number], + "num": NotRequired[_Number], + "output": Required[Literal["html", "md"]], + "place_id": NotRequired[_Scalar], + "q": NotRequired[_Scalar], + "rating": NotRequired[_Scalar], + "sortby": NotRequired[Literal["relevance_desc", "date_desc", "date_asc", "rating_desc", "rating_asc", "elites_desc"]], + "start": NotRequired[_Number], + "yelp_domain": NotRequired[Literal["ms.yelp.my", "www.yelp.cz", "www.yelp.dk", "www.yelp.de", "www.yelp.at", "de.yelp.ch", "www.yelp.com.au", "en.yelp.be", "www.yelp.ca", "en.yelp.com.hk", "en.yelp.my", "www.yelp.co.nz", "en.yelp.com.ph", "www.yelp.ie", "www.yelp.com.sg", "en.yelp.ch", "www.yelp.co.uk", "www.yelp.com", "www.yelp.com.ar", "www.yelp.cl", "www.yelp.es", "www.yelp.com.mx", "fil.yelp.com.ph", "fr.yelp.be", "fr.yelp.ca", "www.yelp.fr", "fr.yelp.ch", "www.yelp.it", "it.yelp.ch", "nl.yelp.be", "www.yelp.nl", "www.yelp.no", "www.yelp.pl", "www.yelp.com.br", "www.yelp.pt", "fi.yelp.fi", "sv.yelp.fi", "www.yelp.com.tr", "www.yelp.co.jp", "zh.yelp.com.hk", "www.yelp.com.tw"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YelpReviewsSearchParams: TypeAlias = Union[YelpReviewsJsonSearchParams, YelpReviewsTextSearchParams] + +YoutubeJsonSearchParams = TypedDict( + "YoutubeJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "search_query": NotRequired[_Scalar], + "sp": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeTextSearchParams = TypedDict( + "YoutubeTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "search_query": NotRequired[_Scalar], + "sp": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeSearchParams: TypeAlias = Union[YoutubeJsonSearchParams, YoutubeTextSearchParams] + +YoutubeChannelJsonSearchParams = TypedDict( + "YoutubeChannelJsonSearchParams", + { + "about": NotRequired[_Flag], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "channel_id": NotRequired[_Scalar], + "engine": Required[Literal["youtube_channel"]], + "gl": NotRequired[str], + "hl": NotRequired[Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "search_query": NotRequired[_Scalar], + "sort": NotRequired[Literal["latest", "popular", "oldest", "dd", "lad"]], + "tab": NotRequired[Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeChannelTextSearchParams = TypedDict( + "YoutubeChannelTextSearchParams", + { + "about": NotRequired[_Flag], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "channel_id": NotRequired[_Scalar], + "engine": Required[Literal["youtube_channel"]], + "gl": NotRequired[str], + "hl": NotRequired[Literal["af", "am", "ar", "az", "be", "bg", "bn", "bs", "ca", "cs", "da", "de", "el", "en", "es", "es-419", "et", "eu", "fa", "fi", "fr", "gl", "gu", "he", "hi", "hr", "hu", "hy", "id", "is", "it", "iw", "ja", "ka", "kk", "km", "kn", "ko", "ky", "lo", "lt", "lv", "mk", "ml", "mn", "mo", "mr", "ms", "my", "ne", "nl", "no", "or", "pa", "pl", "pt", "pt-br", "pt-pt", "ro", "ru", "sh", "si", "sk", "sl", "sq", "sr", "sv", "sw", "ta", "te", "th", "tl", "tr", "uk", "ur", "uz", "vi", "zh-cn", "zh-tw", "zu"]], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "search_query": NotRequired[_Scalar], + "sort": NotRequired[Literal["latest", "popular", "oldest", "dd", "lad"]], + "tab": NotRequired[Literal["home", "videos", "shorts", "streams", "podcasts", "playlists", "posts"]], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeChannelSearchParams: TypeAlias = Union[YoutubeChannelJsonSearchParams, YoutubeChannelTextSearchParams] + +YoutubeVideoJsonSearchParams = TypedDict( + "YoutubeVideoJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube_video"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "v": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeVideoTextSearchParams = TypedDict( + "YoutubeVideoTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube_video"]], + "gl": NotRequired[str], + "hl": NotRequired[str], + "json_restrictor": NotRequired[_Scalar], + "next_page_token": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "v": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeVideoSearchParams: TypeAlias = Union[YoutubeVideoJsonSearchParams, YoutubeVideoTextSearchParams] + +YoutubeVideoTranscriptJsonSearchParams = TypedDict( + "YoutubeVideoTranscriptJsonSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube_video_transcript"]], + "json_restrictor": NotRequired[_Scalar], + "language_code": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "title": NotRequired[_Scalar], + "type": NotRequired[Literal["asr"]], + "v": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeVideoTranscriptTextSearchParams = TypedDict( + "YoutubeVideoTranscriptTextSearchParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "engine": Required[Literal["youtube_video_transcript"]], + "json_restrictor": NotRequired[_Scalar], + "language_code": NotRequired[str], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "title": NotRequired[_Scalar], + "type": NotRequired[Literal["asr"]], + "v": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +YoutubeVideoTranscriptSearchParams: TypeAlias = Union[YoutubeVideoTranscriptJsonSearchParams, YoutubeVideoTranscriptTextSearchParams] + +ZillowJsonSearchParams = TypedDict( + "ZillowJsonSearchParams", + { + "age_55_plus": NotRequired[Literal["include", "exclude", "only"]], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "basement": NotRequired[_Scalar], + "baths": NotRequired[_Scalar], + "beds": NotRequired[_Scalar], + "engine": Required[Literal["zillow"]], + "has_garage": NotRequired[_Flag], + "hide_no_date_listings": NotRequired[_Flag], + "hoa_max": NotRequired[_Number], + "home_type": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "keywords": NotRequired[_Scalar], + "listing_features": NotRequired[_Scalar], + "listing_status": NotRequired[_Scalar], + "listing_type": NotRequired[_Scalar], + "lot_size": NotRequired[_Scalar], + "map_bounds": NotRequired[_Scalar], + "move_in_date": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "page": NotRequired[_Number], + "parking_spots": NotRequired[_Number], + "pets": NotRequired[_Scalar], + "price": NotRequired[_Scalar], + "price_reduction": NotRequired[_Flag], + "region_id": NotRequired[_Scalar], + "short_term_lease": NotRequired[_Flag], + "single_story": NotRequired[_Flag], + "sort_by": NotRequired[Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"]], + "space": NotRequired[Literal["any", "entire_place", "room"]], + "sqft": NotRequired[_Scalar], + "status_type": NotRequired[Literal["sale", "rent", "sold"]], + "time_on_zillow": NotRequired[_Scalar], + "tours": NotRequired[_Scalar], + "view": NotRequired[_Scalar], + "year_built": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ZillowTextSearchParams = TypedDict( + "ZillowTextSearchParams", + { + "age_55_plus": NotRequired[Literal["include", "exclude", "only"]], + "amenities": NotRequired[_Scalar], + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "basement": NotRequired[_Scalar], + "baths": NotRequired[_Scalar], + "beds": NotRequired[_Scalar], + "engine": Required[Literal["zillow"]], + "has_garage": NotRequired[_Flag], + "hide_no_date_listings": NotRequired[_Flag], + "hoa_max": NotRequired[_Number], + "home_type": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "keywords": NotRequired[_Scalar], + "listing_features": NotRequired[_Scalar], + "listing_status": NotRequired[_Scalar], + "listing_type": NotRequired[_Scalar], + "lot_size": NotRequired[_Scalar], + "map_bounds": NotRequired[_Scalar], + "move_in_date": NotRequired[_Scalar], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "page": NotRequired[_Number], + "parking_spots": NotRequired[_Number], + "pets": NotRequired[_Scalar], + "price": NotRequired[_Scalar], + "price_reduction": NotRequired[_Flag], + "region_id": NotRequired[_Scalar], + "short_term_lease": NotRequired[_Flag], + "single_story": NotRequired[_Flag], + "sort_by": NotRequired[Literal["globalrelevanceex", "featured", "priced", "pricea", "paymentd", "paymenta", "days", "beds", "baths", "size", "lot", "priorityscore"]], + "space": NotRequired[Literal["any", "entire_place", "room"]], + "sqft": NotRequired[_Scalar], + "status_type": NotRequired[Literal["sale", "rent", "sold"]], + "time_on_zillow": NotRequired[_Scalar], + "tours": NotRequired[_Scalar], + "view": NotRequired[_Scalar], + "year_built": NotRequired[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ZillowSearchParams: TypeAlias = Union[ZillowJsonSearchParams, ZillowTextSearchParams] + +ExtractJsonParams = TypedDict( + "ExtractJsonParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": NotRequired[Literal["extract"]], + "exclude_tags": NotRequired[_Scalar], + "include_markdown": NotRequired[_Flag], + "include_sitemap": NotRequired[_Flag], + "include_subdomains": NotRequired[_Flag], + "include_tags": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_depth": NotRequired[_Number], + "max_pages": NotRequired[_Number], + "mode": NotRequired[Literal["scrape", "map", "crawl"]], + "no_cache": NotRequired[_Flag], + "output": NotRequired[Literal["json"]], + "prefetch_delay": NotRequired[_Number], + "timeout": NotRequired[_Number], + "url": Required[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ExtractTextParams = TypedDict( + "ExtractTextParams", + { + "api_key": NotRequired[str], + "async": NotRequired[_Flag], + "device": NotRequired[Literal["desktop", "tablet", "mobile"]], + "engine": NotRequired[Literal["extract"]], + "exclude_tags": NotRequired[_Scalar], + "include_markdown": NotRequired[_Flag], + "include_sitemap": NotRequired[_Flag], + "include_subdomains": NotRequired[_Flag], + "include_tags": NotRequired[_Scalar], + "json_restrictor": NotRequired[_Scalar], + "max_depth": NotRequired[_Number], + "max_pages": NotRequired[_Number], + "mode": NotRequired[Literal["scrape", "map", "crawl"]], + "no_cache": NotRequired[_Flag], + "output": Required[Literal["html", "md"]], + "prefetch_delay": NotRequired[_Number], + "timeout": NotRequired[_Number], + "url": Required[_Scalar], + "zero_trace": NotRequired[_Flag], + }, + total=False, +) + +ExtractParams: TypeAlias = Union[ExtractJsonParams, ExtractTextParams] + +SearchArchiveJsonParams = TypedDict( + "SearchArchiveJsonParams", + { + "api_key": NotRequired[str], + "output": NotRequired[Literal["json"]], + "search_id": Required[str], + }, + total=False, +) + +SearchArchiveTextParams = TypedDict( + "SearchArchiveTextParams", + { + "api_key": NotRequired[str], + "output": Required[Literal["html", "md"]], + "search_id": Required[str], + }, + total=False, +) + +SearchArchiveParams: TypeAlias = Union[SearchArchiveJsonParams, SearchArchiveTextParams] + +SearchParams: TypeAlias = Union[ + AirbnbSearchParams, + AmazonSearchParams, + AmazonAutocompleteSearchParams, + AmazonFreshSearchParams, + AmazonProductSearchParams, + AmazonPromotionSearchParams, + AppleAppStoreSearchParams, + AppleMapsSearchParams, + AppleMapsPlacesSearchParams, + AppleProductSearchParams, + AppleReviewsSearchParams, + AutozoneSearchParams, + AutozoneProductSearchParams, + BaiduSearchParams, + BaiduMapsSearchParams, + BaiduNewsSearchParams, + BingSearchParams, + BingCopilotSearchParams, + BingImagesSearchParams, + BingMapsSearchParams, + BingNewsSearchParams, + BingProductSearchParams, + BingReverseImageSearchParams, + BingShoppingSearchParams, + BingVideosSearchParams, + BookingSearchParams, + BraveSearchParams, + BraveAiModeSearchParams, + BraveImagesSearchParams, + BraveVideosSearchParams, + DoordashSearchParams, + DuckAiSearchParams, + DuckduckgoSearchParams, + DuckduckgoLightSearchParams, + DuckduckgoMapsSearchParams, + DuckduckgoNewsSearchParams, + DuckduckgoShoppingSearchParams, + EbaySearchParams, + EbayProductSearchParams, + EbaySellerSearchParams, + EventbriteSearchParams, + ExtractSearchParams, + FacebookMarketplaceSearchParams, + FacebookProfileSearchParams, + Flightradar24SearchParams, + GlassdoorCompaniesSearchParams, + GlassdoorJobsSearchParams, + GlassdoorReviewsSearchParams, + GoogleSearchParams, + GoogleAboutThisResultSearchParams, + GoogleAdsSearchParams, + GoogleAdsTransparencyCenterSearchParams, + GoogleAdsTransparencyCenterAdDetailsSearchParams, + GoogleAiModeSearchParams, + GoogleAiOverviewSearchParams, + GoogleAutocompleteSearchParams, + GoogleBooksSearchParams, + GoogleEventDetailsSearchParams, + GoogleEventsSearchParams, + GoogleFinanceSearchParams, + GoogleFinanceAutocompleteSearchParams, + GoogleFinanceMarketsSearchParams, + GoogleFlightsSearchParams, + GoogleFlightsAutocompleteSearchParams, + GoogleFlightsCalendarSearchParams, + GoogleFlightsDealsSearchParams, + GoogleForumsSearchParams, + GoogleGeminiSearchParams, + GoogleHotelsSearchParams, + GoogleHotelsAutocompleteSearchParams, + GoogleHotelsPhotosSearchParams, + GoogleHotelsPriceCalendarSearchParams, + GoogleHotelsReviewsSearchParams, + GoogleImagesSearchParams, + GoogleImagesLightSearchParams, + GoogleImagesRelatedContentSearchParams, + GoogleImmersiveProductSearchParams, + GoogleJobsSearchParams, + GoogleJobsListingSearchParams, + GoogleLensSearchParams, + GoogleLightSearchParams, + GoogleLocalSearchParams, + GoogleLocalServicesSearchParams, + GoogleMapsSearchParams, + GoogleMapsAutocompleteSearchParams, + GoogleMapsContributorReviewsSearchParams, + GoogleMapsDirectionsSearchParams, + GoogleMapsPhotoMetaSearchParams, + GoogleMapsPhotosSearchParams, + GoogleMapsPostsSearchParams, + GoogleMapsReviewsSearchParams, + GoogleNewsSearchParams, + GoogleNewsLightSearchParams, + GooglePatentsSearchParams, + GooglePatentsDetailsSearchParams, + GooglePlaySearchParams, + GooglePlayBooksSearchParams, + GooglePlayGamesSearchParams, + GooglePlayMoviesSearchParams, + GooglePlayProductSearchParams, + GoogleProductSearchParams, + GoogleRelatedQuestionsSearchParams, + GoogleReverseImageSearchParams, + GoogleScholarSearchParams, + GoogleScholarAuthorSearchParams, + GoogleScholarCaseLawSearchParams, + GoogleScholarCiteSearchParams, + GoogleShoppingSearchParams, + GoogleShoppingFiltersSearchParams, + GoogleShoppingLightSearchParams, + GoogleShortVideosSearchParams, + GoogleSportsSearchParams, + GoogleTranslateSearchParams, + GoogleTravelExploreSearchParams, + GoogleTrendsSearchParams, + GoogleTrendsAutocompleteSearchParams, + GoogleTrendsNewsSearchParams, + GoogleTrendsTrendingNowSearchParams, + GoogleVideosSearchParams, + GoogleVideosLightSearchParams, + HomeDepotSearchParams, + HomeDepotProductSearchParams, + HomeDepotProductReviewsSearchParams, + IndeedJobsSearchParams, + InstagramPopularSearchParams, + InstagramProfileSearchParams, + MetaAdLibrarySearchParams, + NapaSearchParams, + NaverSearchParams, + NaverAiModeSearchParams, + NaverAiOverviewSearchParams, + NaverMapsSearchParams, + OpenTableReviewsSearchParams, + PinterestSearchParams, + SearchIndexSearchParams, + TargetSearchParams, + TiktokDiscoverSearchParams, + TiktokShopSearchParams, + TraderJoesSearchParams, + TraderJoesProductSearchParams, + TripadvisorSearchParams, + TripadvisorPlaceSearchParams, + TripadvisorReviewsSearchParams, + WalmartSearchParams, + WalmartProductSearchParams, + WalmartProductReviewsSearchParams, + WalmartProductSellersSearchParams, + WalmartSellerSearchParams, + YahooSearchParams, + YahooImagesSearchParams, + YahooShoppingSearchParams, + YahooTrendsSearchParams, + YahooVideosSearchParams, + YandexSearchParams, + YandexImagesSearchParams, + YandexVideosSearchParams, + YelpSearchParams, + YelpPlaceSearchParams, + YelpReviewsSearchParams, + YoutubeSearchParams, + YoutubeChannelSearchParams, + YoutubeVideoSearchParams, + YoutubeVideoTranscriptSearchParams, + ZillowSearchParams, +] diff --git a/stubs/serpapi-stubs/exceptions.pyi b/stubs/serpapi-stubs/exceptions.pyi new file mode 100644 index 0000000..e108daf --- /dev/null +++ b/stubs/serpapi-stubs/exceptions.pyi @@ -0,0 +1,15 @@ +from typing import Optional + +import requests + +class SerpApiError(Exception): ... +class APIKeyNotProvided(ValueError, SerpApiError): ... +class SearchIDNotProvided(ValueError, SerpApiError): ... + +class HTTPError(requests.exceptions.HTTPError, SerpApiError): + status_code: int + error: Optional[str] + def __init__(self, original_exception: BaseException) -> None: ... + +class HTTPConnectionError(HTTPError, requests.exceptions.ConnectionError, SerpApiError): ... +class TimeoutError(requests.exceptions.Timeout, SerpApiError): ... diff --git a/stubs/serpapi-stubs/http.pyi b/stubs/serpapi-stubs/http.pyi new file mode 100644 index 0000000..43d0616 --- /dev/null +++ b/stubs/serpapi-stubs/http.pyi @@ -0,0 +1,28 @@ +from typing import Any, Mapping, MutableMapping, Optional, Tuple, Union + +import requests +from typing_extensions import TypeAlias + +_Timeout: TypeAlias = Union[None, float, Tuple[Optional[float], Optional[float]]] +_Proxies: TypeAlias = Union[None, Mapping[str, str]] +_Verify: TypeAlias = Union[None, bool, str] +_Cert: TypeAlias = Union[None, str, Tuple[str, str]] + +class HTTPClient: + BASE_DOMAIN: str + USER_AGENT: str + api_key: Optional[str] + timeout: _Timeout + session: requests.Session + def __init__(self, *, api_key: Optional[str] = None, timeout: _Timeout = None) -> None: ... + def request( + self, + method: str, + path: str, + params: MutableMapping[str, Any], + *, + assert_200: bool = True, + **kwargs: Any, + ) -> requests.Response: ... + +def raise_for_status(r: requests.Response) -> None: ... diff --git a/stubs/serpapi-stubs/models.pyi b/stubs/serpapi-stubs/models.pyi new file mode 100644 index 0000000..33833f4 --- /dev/null +++ b/stubs/serpapi-stubs/models.pyi @@ -0,0 +1,21 @@ +from collections import UserDict +from typing import Any, Dict, Iterator, Mapping, Optional, Union + +import requests + +from .http import HTTPClient + +class SerpResults(UserDict[str, Any]): + client: Optional[HTTPClient] + def __init__(self, data: Mapping[str, Any], *, client: Optional[HTTPClient]) -> None: ... + def __getstate__(self) -> Dict[str, Any]: ... + def __setstate__(self, state: Dict[str, Any]) -> None: ... + def as_dict(self) -> Dict[str, Any]: ... + @property + def next_page_url(self) -> Optional[str]: ... + def next_page(self) -> Optional[SerpResults]: ... + def yield_pages(self, max_pages: int = 1000) -> Iterator[SerpResults]: ... + @classmethod + def from_http_response( + cls, r: requests.Response, *, client: Optional[HTTPClient] = None + ) -> Union[SerpResults, str]: ... diff --git a/stubs/serpapi-stubs/textui.pyi b/stubs/serpapi-stubs/textui.pyi new file mode 100644 index 0000000..fd41703 --- /dev/null +++ b/stubs/serpapi-stubs/textui.pyi @@ -0,0 +1,6 @@ +from types import ModuleType +from typing import Optional + +pygments: Optional[ModuleType] + +def prettify_json(s: str) -> str: ... diff --git a/stubs/serpapi-stubs/utils.pyi b/stubs/serpapi-stubs/utils.pyi new file mode 100644 index 0000000..06f585e --- /dev/null +++ b/stubs/serpapi-stubs/utils.pyi @@ -0,0 +1,3 @@ +from typing import Optional + +def api_key_from_environment() -> Optional[str]: ... diff --git a/stubs/tests/conftest.py b/stubs/tests/conftest.py new file mode 100644 index 0000000..6d29d23 --- /dev/null +++ b/stubs/tests/conftest.py @@ -0,0 +1,4 @@ +import sys +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "tools")) diff --git a/stubs/tests/stubtest_allowlist.txt b/stubs/tests/stubtest_allowlist.txt new file mode 100644 index 0000000..6078908 --- /dev/null +++ b/stubs/tests/stubtest_allowlist.txt @@ -0,0 +1,2 @@ +# Typing-only module: TypedDicts for SerpApi parameters exist only in the stubs. +serpapi.engine_params diff --git a/stubs/tests/test_fetch_engines.py b/stubs/tests/test_fetch_engines.py new file mode 100644 index 0000000..d43bd96 --- /dev/null +++ b/stubs/tests/test_fetch_engines.py @@ -0,0 +1,112 @@ +import html +import json + +import pytest + +import fetch_engines + + +def engine(*params, required=True): + group = {"engine": {"type": "select", "required": required}} + group.update({name: metadata for name, metadata in params}) + return {"serpapi_parameters": {"name": "SerpApi", "parameters": group}} + + +def playground(parameters): + props = html.escape(json.dumps({"parameters": parameters}), quote=True) + return f'
' + + +@pytest.fixture +def few_engines(monkeypatch): + monkeypatch.setattr(fetch_engines, "MIN_ENGINES", 2) + + +def test_extract_props_picks_element_with_parameters(): + assert fetch_engines.extract_props(playground({"google": {}})) == {"parameters": {"google": {}}} + + +def test_extract_props_requires_parameters(): + with pytest.raises(ValueError, match="no data-react-props"): + fetch_engines.extract_props('
') + + +@pytest.mark.parametrize( + ("name", "metadata", "engine", "expected"), + [ + ("name", {"type": "select", "options": [["active", "Active"], ["off", "Off"]]}, None, {"type": "select", "options": ["active", "off"]}), + ("name", {"type": "dropdown", "options": ["a", "b"]}, None, {"type": "dropdown", "options": ["a", "b"]}), + ("name", {"type": "device", "options": ["mobile", "tablet"]}, None, {"type": "device", "options": ["mobile", "tablet"]}), + ("name", {"options": [["10", "10"], ["20", "20"]]}, None, {"value_type": "number"}), + ("name", {"options": ["4.5", "-1.25"]}, None, {"value_type": "number"}), + ("language", {"type": "select", "options": ["amazon.com|en_US", "amazon.co.uk|en_GB"]}, "amazon", {"type": "select", "options": ["en_US", "en_GB"]}), + ("name", {"type": "select", "options": [[str(i) + "x", "x"] for i in range(fetch_engines.MAX_LITERAL_OPTIONS + 1)]}, None, {"type": "select", "value_type": "string"}), + ("name", {"type": "checkbox", "required": "true"}, None, {"type": "checkbox"}), + ("name", {"required": True, "options": [[True, "yes"]]}, None, {"required": True}), + # Options without a closed-choice type, such as a comma-separated multi-value list, are open strings. + ("type_of_visit", {"options": ["Business", "Couples"], "html": "Separate values with a comma"}, None, {"value_type": "string"}), + ("name", {"type": "text", "options": ["a", "b"]}, None, {"type": "text", "value_type": "string"}), + # Values documented in a different case than the options mean matching is case-insensitive. + ("mkt", {"type": "select", "options": ["en-us", "de-de"], "html": "Case insensitive, e.g. en-US"}, None, {"type": "select", "value_type": "string"}), + ("cc", {"type": "select", "options": ["DE", "US"], "html": "de — us"}, None, {"type": "select", "value_type": "string"}), + # Documented values that match exactly, or are unrelated to the options, keep the closed list. + ("mkt", {"type": "select", "options": ["en-us", "de-de"], "html": "Use en-us or de-de"}, None, {"type": "select", "options": ["en-us", "de-de"]}), + ("mkt", {"type": "select", "options": ["en-us", "de-de"], "html": "Defaults to all"}, None, {"type": "select", "options": ["en-us", "de-de"]}), + ], +) +def test_normalize_param(name, metadata, engine, expected): + assert fetch_engines.normalize_param(name, metadata, engine) == expected + + +def test_normalize_props_sorts_and_excludes(few_engines): + snapshot = fetch_engines.normalize_props( + { + "parameters": { + "google": engine(("q", {}), ("device", {"type": "select", "options": [["mobile", "Mobile"]]}), required=False), + "extract": engine(("url", {"required": True})), + "google_light_fast": engine(), + } + } + ) + assert list(snapshot["engines"]) == ["extract", "google"] + assert list(snapshot["engines"]["google"]) == ["device", "engine", "q"] + assert snapshot["engines"]["google"]["device"] == {"type": "select", "options": ["mobile"]} + assert snapshot["engines"]["google"]["engine"] == {"type": "select"} + + +def test_normalize_param_converts_amazon_language_options(): + language = fetch_engines.normalize_param( + "language", + {"type": "select", "options": ["amazon.com|en_US", "amazon.co.uk|en_GB"]}, + "amazon", + ) + assert language["options"] == ["en_US", "en_GB"] + + +@pytest.mark.parametrize( + ("parameters", "message"), + [ + ({"google": engine(), "bing": {"group": {"parameters": {"q": {}}}}}, "no 'engine' parameter"), + ({"google": engine(), "bing": engine()}, "missing expected engines: extract"), + ({"google": engine(), "extract": {"group": []}}, "has no parameters object"), + ], +) +def test_normalize_props_rejects_malformed_metadata(few_engines, parameters, message): + with pytest.raises(ValueError, match=message): + fetch_engines.normalize_props({"parameters": parameters}) + + +def test_normalize_props_requires_minimum_engine_count(): + with pytest.raises(ValueError, match="expected at least"): + fetch_engines.normalize_props({"parameters": {"google": engine(), "extract": engine()}}) + + +def test_main_writes_snapshot_only_when_changed(tmp_path, few_engines, capsys): + page = tmp_path / "playground.html" + page.write_text(playground({"google": engine(("q", {})), "extract": engine()}), encoding="utf-8") + output = tmp_path / "engines.json" + + assert fetch_engines.main(["--html", str(page), "--output", str(output)]) == 0 + assert json.loads(output.read_text())["engines"]["google"]["q"] == {} + assert fetch_engines.main(["--html", str(page), "--output", str(output)]) == 0 + assert capsys.readouterr().out.splitlines()[-1].startswith("Unchanged") diff --git a/stubs/tests/test_generate_stubs.py b/stubs/tests/test_generate_stubs.py new file mode 100644 index 0000000..ef5420a --- /dev/null +++ b/stubs/tests/test_generate_stubs.py @@ -0,0 +1,149 @@ +import ast +import json + +import pytest + +import generate_stubs + +SNAPSHOT = { + "engines": { + "google": { + "engine": {}, + "q": {"required": True}, + "device": {"type": "select", "options": ["desktop", "mobile"]}, + "num": {"type": "number"}, + "nfpr": {"type": "checkbox"}, + "async": {}, + }, + "google_lens": {"engine": {"required": True}, "url": {"required": True}, "image_id": {}}, + "google_translate": {"engine": {"required": True}, "from": {"required": True}, "text": {}}, + "naver": {"engine": {"required": True}, "page": {}, "start": {}, "num": {}}, + "extract": {"engine": {"required": True}, "url": {"required": True}, "timeout": {"type": "number"}}, + } +} + + +@pytest.fixture +def snapshot(tmp_path): + path = tmp_path / "engines.json" + path.write_text(json.dumps(SNAPSHOT)) + return path + + +@pytest.fixture +def engines(snapshot): + return {engine.name: engine for engine in generate_stubs.load_engines(snapshot)} + + +def params(engine): + return {param.name: param for param in engine.params} + + +def test_param_types(engines): + google = params(engines["google"]) + assert google["device"].typ == 'Literal["desktop", "mobile"]' + assert google["num"].typ == "_Number" + assert google["nfpr"].typ == "_Flag" + assert google["async"].typ == "_Flag" + assert google["q"].typ == "_Scalar" + naver = params(engines["naver"]) + assert naver["page"].typ == "_Number" + assert naver["start"].typ == "_Number" + assert naver["num"].typ == "_Number" + + +@pytest.mark.parametrize( + ("name", "metadata", "expected"), + [ + # The SDK sends numbers as text, so a parameter the playground leaves untyped accepts them. + ("min_price", {}, "_Scalar"), + ("store_id", {"required": True}, "_Scalar"), + ("mkt", {"type": "select", "value_type": "string"}, "str"), + ("location", {"type": "location"}, "str"), + ("type_of_visit", {"value_type": "string"}, "str"), + ("api_key", {}, "str"), + ], +) +def test_untyped_params_accept_numbers(name, metadata, expected): + assert generate_stubs.param_type(name, metadata) == expected + + +def test_only_api_mandatory_params_are_required(engines): + assert not params(engines["google"])["q"].required + assert not params(engines["google_lens"])["url"].required + assert params(engines["extract"])["url"].required + + +def test_only_google_can_omit_engine(tmp_path): + path = tmp_path / "engines.json" + # The playground's `required` flag on `engine` must not decide this. + path.write_text( + json.dumps( + { + "engines": { + "google": {"engine": {"required": True}, "q": {}}, + "bing": {"engine": {}, "q": {}}, + "extract": {"engine": {}, "url": {"required": True}}, + } + } + ) + ) + loaded = {engine.name: engine for engine in generate_stubs.load_engines(path)} + assert not loaded["google"].engine_required + assert loaded["bing"].engine_required + + +def test_keyword_overloads_skip_names_python_cannot_pass(engines): + names = {param.name for param in generate_stubs.keyword_params(list(engines["google"].params), text=False)} + assert "async" not in names + assert {"q", "device", "output", "timeout"} <= names + + translate = {param.name for param in generate_stubs.keyword_params(list(engines["google_translate"].params), text=False)} + assert "from" not in translate and "text" in translate + + +def test_extract_timeout_keyword_is_the_http_timeout(engines): + timeouts = [param for param in generate_stubs.keyword_params(list(engines["extract"].params), text=False) if param.name == "timeout"] + assert [param.typ for param in timeouts] == ["_Timeout"] + + +def test_rendered_stubs_are_valid_and_cover_engine_shapes(snapshot): + outputs = generate_stubs.render(snapshot) + for content in outputs.values(): + ast.parse(content) + core = outputs["core.pyi"] + assert "engine: Literal[\"google\"]" in core + assert '"from": NotRequired[_Scalar]' in outputs["engine_params.pyi"] + assert '"url": Required[_Scalar]' in outputs["engine_params.pyi"] + assert "params: None = None" in core + + +def test_only_extract_accepts_read_only_mappings(snapshot): + core = generate_stubs.render(snapshot)["core.pyi"] + + def fallback(function): + overloads = core.split(f"def {function}(")[1:] + return next(overload.split(") ->")[0] for overload in overloads if "**kwargs: Any," in overload.split(") ->")[0]) + + assert "params: Union[SearchParams, MutableMapping[str, Any]]," in fallback("search") + assert "params: Union[SearchArchiveParams, MutableMapping[str, Any]]," in fallback("search_archive") + assert "params: Mapping[str, Any]," in fallback("extract") + assert "def locations(params: Optional[MutableMapping[str, Any]] = None" in core + + +def test_google_can_omit_engine(snapshot): + core = generate_stubs.render(snapshot)["core.pyi"] + search_overloads = core.split("def search(")[1:] + assert any("engine:" not in overload.split(") ->")[0] and "q: _Scalar" in overload for overload in search_overloads) + + +def test_check_reports_stale_files(snapshot, tmp_path, capsys): + out = tmp_path / "out" + assert generate_stubs.main(["--snapshot", str(snapshot), "--output-dir", str(out), "--check"]) == 1 + assert generate_stubs.main(["--snapshot", str(snapshot), "--output-dir", str(out)]) == 0 + assert generate_stubs.main(["--snapshot", str(snapshot), "--output-dir", str(out), "--check"]) == 0 + assert "out of date" in capsys.readouterr().err + + +def test_committed_stubs_match_snapshot(): + assert generate_stubs.stale_files(generate_stubs.render()) == [] diff --git a/stubs/tests/test_packaging.py b/stubs/tests/test_packaging.py new file mode 100644 index 0000000..02d3c1a --- /dev/null +++ b/stubs/tests/test_packaging.py @@ -0,0 +1,7 @@ +from pathlib import Path + +STUBS_ROOT = Path(__file__).resolve().parent.parent + + +def test_license_matches_the_sdk_license(): + assert (STUBS_ROOT / "LICENSE").read_bytes() == (STUBS_ROOT.parent / "LICENSE").read_bytes() diff --git a/stubs/tests/test_release_version.py b/stubs/tests/test_release_version.py new file mode 100644 index 0000000..79bc71b --- /dev/null +++ b/stubs/tests/test_release_version.py @@ -0,0 +1,118 @@ +import datetime +import io +import json +from urllib.error import HTTPError + +import pytest + +import release_version + +DAY = datetime.date(2026, 1, 2) + + +@pytest.mark.parametrize( + ("existing", "expected"), + [ + (set(), "1.2.0.20260102"), + ({"1.2.0.20260101"}, "1.2.0.20260102"), + ({"1.2.0.20260102"}, "1.2.0.20260102.1"), + ({"1.2.0.20260102", "1.2.0.20260102.1"}, "1.2.0.20260102.2"), + ], +) +def test_next_version(existing, expected): + assert release_version.next_version("1.2.0", DAY, existing) == expected + + +@pytest.mark.parametrize( + ("existing", "expected"), + [ + (set(), False), + ({"1.2.0.20260101"}, True), + ({"1.2.1.20260102"}, False), + ({"1.2.0rc1.20260102"}, False), + ], +) +def test_has_published_series(existing, expected): + assert release_version.has_published_series("1.2.0", existing) is expected + + +@pytest.mark.parametrize( + "version", ["1.3.0b1", "1.2.0.post1", "1.2.0.dev0", "1.2.0+local", "1.2", "1.2.0.1"] +) +def test_read_sdk_version_rejects_non_final_releases(tmp_path, version): + path = tmp_path / "__version__.py" + path.write_text(f'__version__ = "{version}"\n') + with pytest.raises(ValueError, match="not a final X.Y.Z release"): + release_version.read_sdk_version(path) + + +def respond_with(payload): + def urlopen(request, timeout): + return io.BytesIO(json.dumps(payload).encode()) + + return urlopen + + +def test_published_versions_reads_release_keys(monkeypatch): + monkeypatch.setattr( + release_version, "urlopen", respond_with({"releases": {"1.2.0.20260101": [], "1.2.0.20260102": []}}) + ) + assert release_version.published_versions() == {"1.2.0.20260101", "1.2.0.20260102"} + + +def test_published_versions_fails_on_unexpected_payload(monkeypatch): + monkeypatch.setattr(release_version, "urlopen", respond_with({"info": {}})) + with pytest.raises(KeyError): + release_version.published_versions() + + +def test_published_versions_treats_missing_project_as_empty(monkeypatch): + def not_found(request, timeout): + raise HTTPError(request.full_url, 404, "Not Found", {}, io.BytesIO()) + + monkeypatch.setattr(release_version, "urlopen", not_found) + assert release_version.published_versions() == set() + + +def test_published_versions_does_not_hide_other_http_errors(monkeypatch): + def unavailable(request, timeout): + raise HTTPError(request.full_url, 503, "Service Unavailable", {}, io.BytesIO()) + + monkeypatch.setattr(release_version, "urlopen", unavailable) + with pytest.raises(HTTPError): + release_version.published_versions() + + +def test_main_writes_version_file(tmp_path): + output = tmp_path / "VERSION" + + assert release_version.main(["--offline", "--date", "20260102", "--output", str(output)]) == 0 + + assert output.read_text() == f"{release_version.read_sdk_version()}.20260102\n" + + +@pytest.mark.parametrize( + ("tag", "existing", "exit_code", "github_output"), + [ + ("v1.2.0", set(), 0, "publish=true\n"), + ("v1.2.0", {"1.2.0.20260101"}, 0, "publish=false\n"), + # A tag that does not name the SDK version must stop the release before anything is uploaded. + ("v1.2.1", set(), 1, ""), + ("v1.2.0-rc1", set(), 1, ""), + ("master", set(), 1, ""), + ], +) +def test_series_check(tmp_path, monkeypatch, tag, existing, exit_code, github_output): + output = tmp_path / "github_output" + output.touch() + monkeypatch.setenv("GITHUB_OUTPUT", str(output)) + monkeypatch.setattr(release_version, "read_sdk_version", lambda: "1.2.0") + monkeypatch.setattr(release_version, "published_versions", lambda: existing) + + assert release_version.main(["--series-check", tag]) == exit_code + assert output.read_text() == github_output + + +def test_sdk_version_flag_prints_the_sdk_version(capsys): + assert release_version.main(["--sdk-version"]) == 0 + assert capsys.readouterr().out == release_version.read_sdk_version() + "\n" diff --git a/stubs/tests/typecheck/check_errors.py b/stubs/tests/typecheck/check_errors.py new file mode 100644 index 0000000..a9d8d7a --- /dev/null +++ b/stubs/tests/typecheck/check_errors.py @@ -0,0 +1,32 @@ +"""Calls that must be rejected. Each `# type: ignore` must be needed (unused ignores fail the check).""" + +from types import MappingProxyType +from typing import TYPE_CHECKING + +import serpapi + +if TYPE_CHECKING: + from serpapi.engine_params import ExtractJsonParams, GoogleJsonSearchParams, SearchArchiveTextParams + +client = serpapi.Client(api_key="secret") + +client.search(engine="google", q="coffee", locaton="Austin") # type: ignore +client.search(engine="gogle", q="coffee") # type: ignore +client.search(search_query="coffee") # type: ignore +client.search(engine="google", q="coffee", device="watch") # type: ignore +client.search(engine="google", q="coffee", output="xml") # type: ignore +client.search(engine="google", q="coffee", timeout="30") # type: ignore +serpapi.extract() # type: ignore +client.search_archive() # type: ignore +serpapi.Client("secret") # type: ignore +serpapi.upload_image(123) # type: ignore + +# search() and search_archive() write the API key into the mapping they receive. +client.search(MappingProxyType({"engine": "google", "q": "coffee"})) # type: ignore +client.search_archive(MappingProxyType({"search_id": "abc"})) # type: ignore + +# Untyped dict literals fall back to Mapping[str, Any]; annotate them with a TypedDict for key checking. +typo: "GoogleJsonSearchParams" = {"engine": "google", "qq": "coffee"} # type: ignore +bad_output: "GoogleJsonSearchParams" = {"engine": "google", "q": "coffee", "output": "md"} # type: ignore +no_url: "ExtractJsonParams" = {"timeout": 30000} # type: ignore +no_search_id: "SearchArchiveTextParams" = {"output": "md"} # type: ignore diff --git a/stubs/tests/typecheck/check_usage.py b/stubs/tests/typecheck/check_usage.py new file mode 100644 index 0000000..69fe91d --- /dev/null +++ b/stubs/tests/typecheck/check_usage.py @@ -0,0 +1,77 @@ +"""Calls that must type-check, with their expected types.""" + +from types import MappingProxyType +from typing import TYPE_CHECKING, Any, Dict, List, Union + +from typing_extensions import assert_type + +import serpapi +from serpapi import Client, SerpResults + +if TYPE_CHECKING: + from serpapi.engine_params import GoogleJsonSearchParams, SearchArchiveParams, SearchParams + +client = Client(api_key="secret", timeout=20) + +assert_type(client.search(engine="google", q="coffee"), SerpResults) +assert_type(client.search(q="coffee", location="Austin, Texas", no_cache=True), SerpResults) +assert_type(client.search(engine="bing", q="coffee", output="html"), str) +assert_type(client.search(engine="bing", q="coffee", mkt="en-US", cc="us", safeSearch="Moderate"), SerpResults) +assert_type(client.search(engine="tripadvisor_reviews", place_id="g60763", type_of_visit="Business,Couples"), SerpResults) +assert_type(client.search(engine="yahoo_shopping", p="tv", min_price=100), SerpResults) +assert_type(client.search(engine="home_depot", q="chair", store_id=2118), SerpResults) +assert_type(client.search(engine="google_lens", image_id="abc", hl="en"), SerpResults) +assert_type(client.search(engine="google", q="coffee", timeout=(3.0, 30.0), verify=False), SerpResults) +assert_type(client.search(engine="google", q="coffee", proxies=None, cert=None, verify=None, stream=None), SerpResults) +assert_type(client.search(engine="google_maps", q="coffee", min_rating=4.5), SerpResults) +assert_type(client.search(engine="doordash", q="coffee", min_rating=4.5), SerpResults) +assert_type(client.search(engine="amazon", k="coffee", language="en_US"), SerpResults) +assert_type(client.search(engine="naver", query="coffee", page=2, start=21), SerpResults) +assert_type(client.search({"engine": "google", "q": "coffee", "async": True}), SerpResults) +client.search({"engine": "google_images", "tbm": "isch", "q": "coffee"}) +client.search({"engine": "google_play", "q": "kite", "store": "apps", "max_results": "2"}) +assert_type(client.search({"engine": "google", "q": "coffee", "output": "md"}), str) +assert_type(client.search({"engine": "google_translate", "text": "hi", "from": "en"}), SerpResults) +assert_type(client.search({"engine": "google", "q": "coffee", "async": True}), SerpResults) +assert_type(serpapi.search(engine="google", q="coffee", output="md"), str) + +def runtime_engine(name: str) -> None: + assert_type(client.search({"engine": name, "q": "coffee"}), Union[SerpResults, Any]) + +params: Dict[str, Any] = {"engine": "google", "q": "coffee"} +assert_type(client.search(params), Union[SerpResults, Any]) +assert_type(client.search(params, start=10), Union[SerpResults, Any]) + +typed: "GoogleJsonSearchParams" = {"engine": "google", "q": "coffee", "device": "mobile"} +assert_type(client.search(typed), SerpResults) +assert_type(client.search(typed, start=10), Union[SerpResults, Any]) + + +# Function parameters keep their declared union; a module-level assignment would be narrowed. +def any_engine(params: "SearchParams", archive: "SearchArchiveParams") -> None: + assert_type(client.search(params), Union[SerpResults, Any]) + assert_type(client.search_archive(archive), Union[SerpResults, Any]) + + +assert_type(client.extract(url="https://example.com"), SerpResults) +assert_type(client.extract(MappingProxyType({"url": "https://example.com"})), Union[SerpResults, Any]) +assert_type(client.extract({"url": "https://example.com", "timeout": 30000, "output": "md"}), str) +assert_type(serpapi.search_archive(search_id="abc"), SerpResults) +assert_type(client.search_archive({"search_id": "abc", "output": "html"}), str) + +results = client.search(q="coffee") +assert_type(results.next_page_url, Union[str, None]) +assert_type(results.next_page(), Union[SerpResults, None]) +for page in results.yield_pages(max_pages=2): + assert_type(page, SerpResults) +assert_type(results.as_dict(), Dict[str, Any]) + +assert_type(client.upload_image("photo.jpg"), Dict[str, Any]) +assert_type(serpapi.locations(q="Austin", limit=3), List[Dict[str, Any]]) +assert_type(serpapi.account(), Dict[str, Any]) + +try: + client.search(q="coffee") +except serpapi.HTTPError as error: + assert_type(error.status_code, int) + assert_type(error.error, Union[str, None]) diff --git a/stubs/tools/fetch_engines.py b/stubs/tools/fetch_engines.py new file mode 100644 index 0000000..268358b --- /dev/null +++ b/stubs/tools/fetch_engines.py @@ -0,0 +1,194 @@ +#!/usr/bin/env python3 +"""Fetch SerpApi engine parameters from the playground and write a normalized snapshot.""" + +from __future__ import annotations + +import argparse +import html +import json +import math +import os +import re +import sys +import tempfile +from html.parser import HTMLParser +from pathlib import Path +from typing import Any +from urllib.request import Request, urlopen + +PLAYGROUND_URL = "https://serpapi.com/playground" +SNAPSHOT_PATH = Path(__file__).resolve().parent.parent / "data" / "engines.json" +EXCLUDED_ENGINES = frozenset({"google_scholar_profiles", "google_light_fast", "google_lens_image_sources"}) +REQUIRED_ENGINES = ("google", "extract") +MIN_ENGINES = 50 +MAX_LITERAL_OPTIONS = 80 +# Playground parameter types whose options are the complete list of accepted values. +CLOSED_CHOICE_TYPES = frozenset({"select", "dropdown", "device"}) +DOCUMENTED_VALUE = re.compile(r"(.*?)", re.DOTALL) +TIMEOUT_SECONDS = 60 +USER_AGENT = "serpapi-stubs-refresh (+https://github.com/serpapi/serpapi-python)" + + +class _ReactPropsParser(HTMLParser): + def __init__(self) -> None: + super().__init__() + self.props: list[str] = [] + + def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None: + for name, value in attrs: + if name == "data-react-props" and value: + self.props.append(value) + + +def extract_props(page_html: str) -> dict[str, Any]: + parser = _ReactPropsParser() + parser.feed(page_html) + for raw in parser.props: + props = json.loads(raw) + if isinstance(props, dict) and isinstance(props.get("parameters"), dict): + return props + raise ValueError("Playground HTML has no data-react-props element with engine parameters") + + +def _option_value(option: Any) -> Any: + return option[0] if isinstance(option, list) and option else option + + +def _is_numeric(value: Any) -> bool: + if isinstance(value, bool): + return False + if isinstance(value, int): + return True + if isinstance(value, float): + return math.isfinite(value) + if isinstance(value, str): + try: + return math.isfinite(float(value)) + except ValueError: + return False + return False + + +def _is_closed_choice(metadata: dict[str, Any], values: list[str]) -> bool: + """Whether the options are the only accepted values, so a Literal type does not reject valid calls.""" + if metadata.get("type") not in CLOSED_CHOICE_TYPES: + return False + # Some options are documented in another case than the option list (e.g. Bing's `mkt`, `cc`), which + # means the API does not match case-sensitively. + description = metadata.get("html") + documented = DOCUMENTED_VALUE.findall(description) if isinstance(description, str) else [] + accepted = set(values) + folded = {value.casefold() for value in values} + for token in documented: + value = html.unescape(token).strip() + if value not in accepted and value.casefold() in folded: + return False + return True + + +def normalize_param(name: str, metadata: Any, engine: str | None = None) -> dict[str, Any]: + if not isinstance(metadata, dict): + raise ValueError(f"Parameter {name!r} metadata is not an object") + param: dict[str, Any] = {} + param_type = metadata.get("type") + if isinstance(param_type, str) and param_type: + param["type"] = param_type + if metadata.get("required") is True: + param["required"] = True + options = metadata.get("options") + if isinstance(options, list) and options: + values = [] + for option in options: + value = _option_value(option) + if isinstance(value, (str, int, float)) and not isinstance(value, bool) and value not in values: + values.append(value) + if name == "language" and engine and engine.startswith("amazon"): + values = list(dict.fromkeys(value.rsplit("|", 1)[-1] for value in values if isinstance(value, str))) + if values and any(_is_numeric(value) for value in values): + param["value_type"] = "number" + elif values: + literal = len(values) <= MAX_LITERAL_OPTIONS and all(isinstance(value, str) for value in values) + if literal and _is_closed_choice(metadata, values): + param["options"] = values + else: + param["value_type"] = "string" + return param + + +def normalize_props(props: dict[str, Any]) -> dict[str, Any]: + parameters = props.get("parameters") + if not isinstance(parameters, dict): + raise ValueError("Playground props are missing the 'parameters' object") + + engines: dict[str, dict[str, Any]] = {} + for engine, groups in parameters.items(): + if not isinstance(engine, str) or not engine or engine in EXCLUDED_ENGINES: + continue + if not isinstance(groups, dict): + raise ValueError(f"Engine {engine!r} metadata is not an object") + params: dict[str, Any] = {} + for group_name, group in groups.items(): + group_params = group.get("parameters") if isinstance(group, dict) else None + if not isinstance(group_params, dict): + raise ValueError(f"Engine {engine!r} group {group_name!r} has no parameters object") + for name, metadata in group_params.items(): + if not isinstance(name, str) or not name: + raise ValueError(f"Engine {engine!r} has an invalid parameter name") + params[name] = normalize_param(name, metadata, engine) + if "engine" not in params: + raise ValueError(f"Engine {engine!r} has no 'engine' parameter") + engines[engine] = {name: params[name] for name in sorted(params)} + + missing = [engine for engine in REQUIRED_ENGINES if engine not in engines] + if missing: + raise ValueError(f"Playground metadata is missing expected engines: {', '.join(missing)}") + if len(engines) < MIN_ENGINES: + raise ValueError(f"Playground metadata has only {len(engines)} engines; expected at least {MIN_ENGINES}") + + return {"source": PLAYGROUND_URL, "engines": {name: engines[name] for name in sorted(engines)}} + + +def render_snapshot(snapshot: dict[str, Any]) -> str: + return json.dumps(snapshot, indent=2, ensure_ascii=False) + "\n" + + +def write_atomic(path: Path, content: str) -> bool: + if path.exists() and path.read_text(encoding="utf-8") == content: + return False + path.parent.mkdir(parents=True, exist_ok=True) + fd, tmp_name = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.", suffix=".tmp") + try: + with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle: + handle.write(content) + os.replace(tmp_name, path) + except BaseException: + Path(tmp_name).unlink(missing_ok=True) + raise + return True + + +def download_playground(url: str = PLAYGROUND_URL) -> str: + request = Request(url, headers={"User-Agent": USER_AGENT}) + with urlopen(request, timeout=TIMEOUT_SECONDS) as response: + return response.read().decode("utf-8") + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--html", type=Path, help="read a saved playground page instead of downloading it") + parser.add_argument("--output", type=Path, default=SNAPSHOT_PATH) + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + args = parse_args(sys.argv[1:] if argv is None else argv) + page_html = args.html.read_text(encoding="utf-8") if args.html else download_playground() + snapshot = normalize_props(extract_props(page_html)) + changed = write_atomic(args.output, render_snapshot(snapshot)) + state = "Updated" if changed else "Unchanged" + print(f"{state} {args.output} ({len(snapshot['engines'])} engines)") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/stubs/tools/generate_stubs.py b/stubs/tools/generate_stubs.py new file mode 100644 index 0000000..4d1a9e4 --- /dev/null +++ b/stubs/tools/generate_stubs.py @@ -0,0 +1,380 @@ +#!/usr/bin/env python3 +"""Generate serpapi-stubs engine-specific stubs from the normalized engine snapshot.""" + +from __future__ import annotations + +import argparse +import ast +import json +import keyword +import re +import sys +from dataclasses import dataclass +from pathlib import Path +from typing import Any + +STUBS_ROOT = Path(__file__).resolve().parent.parent +SNAPSHOT_PATH = STUBS_ROOT / "data" / "engines.json" +OUTPUT_DIR = STUBS_ROOT / "serpapi-stubs" +GENERATED_FILES = ("core.pyi", "engine_params.pyi") +REQUEST_OPTIONS = ( + ("cert", "_Cert"), + ("proxies", "_Proxies"), + ("stream", "Optional[bool]"), + ("timeout", "_Timeout"), + ("verify", "_Verify"), +) +REQUEST_OPTION_NAMES = frozenset(name for name, _ in REQUEST_OPTIONS) +NUMERIC_PARAM_NAMES = frozenset({"limit", "num", "offset", "page", "start"}) +BOOLEAN_PARAM_NAMES = frozenset({"async", "include_filters", "no_cache", "zero_trace"}) +RESERVED_KEYWORD_NAMES = frozenset({"params", "self"}) +# Playground "required" flags are often conditional (for example, google_lens `url` can be replaced by +# `image_id`), so only parameters the API cannot work without are required. +REQUIRED_PARAMS = {"extract": frozenset({"url"})} +# SerpApi runs Google when `engine` is omitted, so only Google calls may leave it out. +DEFAULT_ENGINE = "google" +JSON_OUTPUT = 'Literal["json"]' +TEXT_OUTPUT = 'Literal["html", "md"]' +FALLBACK_RETURN = "Union[SerpResults, Any]" +# search(), search_archive(), locations() and account() write the API key and keyword parameters into the +# mapping they are given, so a read-only Mapping fails at runtime; extract() copies it. TypedDicts are not +# MutableMapping, so the fallback overloads list the engine types next to it. +MUTABLE_PARAMS = "MutableMapping[str, Any]" +HEADER = ( + "# Generated by stubs/tools/generate_stubs.py from stubs/data/engines.json.\n" + "# Do not edit by hand; run `python stubs/tools/generate_stubs.py` instead.\n" +) + + +@dataclass(frozen=True) +class Param: + name: str + typ: str + required: bool + + +ARCHIVE_PARAMS = (Param("api_key", "str", False), Param("search_id", "str", True)) + + +@dataclass(frozen=True) +class Engine: + name: str + class_prefix: str + params: tuple[Param, ...] + engine_required: bool + + @property + def json_params(self) -> str: + return f"{self.class_prefix}JsonSearchParams" + + @property + def text_params(self) -> str: + return f"{self.class_prefix}TextSearchParams" + + @property + def search_params(self) -> str: + return f"{self.class_prefix}SearchParams" + + +def class_prefix(engine: str) -> str: + return "".join(part[:1].upper() + part[1:] for part in re.split(r"[^0-9A-Za-z]+", engine) if part) + + +def is_keyword_argument(name: str) -> bool: + return name.isidentifier() and not keyword.iskeyword(name) and name not in RESERVED_KEYWORD_NAMES + + +def literal(values: list[Any]) -> str: + return "Literal[" + ", ".join(json.dumps(value) for value in values) + "]" + + +def param_type(name: str, metadata: dict[str, Any]) -> str: + if name == "api_key": + return "str" + if name in BOOLEAN_PARAM_NAMES or metadata.get("type") == "checkbox": + return "_Flag" + if metadata.get("type") == "number" or metadata.get("value_type") == "number": + return "_Number" + options = metadata.get("options") + if isinstance(options, list) and options: + return literal(options) + if not (metadata.get("type") or options or metadata.get("value_type")): + # The playground does not say what these hold, and the SDK sends numbers as text. + return "_Number" if name in NUMERIC_PARAM_NAMES else "_Scalar" + return "str" + + +def load_engines(snapshot_path: Path = SNAPSHOT_PATH) -> list[Engine]: + snapshot = json.loads(snapshot_path.read_text(encoding="utf-8")) + raw_engines = snapshot.get("engines") if isinstance(snapshot, dict) else None + if not isinstance(raw_engines, dict) or not raw_engines: + raise ValueError(f"{snapshot_path} has no engines") + + engines = [] + prefixes: dict[str, str] = {} + for name in sorted(raw_engines): + raw_params = raw_engines[name] + if not isinstance(raw_params, dict): + raise ValueError(f"Engine {name!r} parameters are not an object") + prefix = class_prefix(name) + if not prefix or prefix in prefixes: + raise ValueError(f"Engine {name!r} has an empty or duplicate class name {prefix!r}") + prefixes[prefix] = name + + params = [ + Param( + param_name, + param_type(param_name, metadata), + param_name in REQUIRED_PARAMS.get(name, ()), + ) + for param_name, metadata in sorted(raw_params.items()) + if param_name not in {"engine", "output"} + ] + engine_required = name != DEFAULT_ENGINE + engines.append(Engine(name, prefix, tuple(params), engine_required)) + if not any(engine.name == "extract" for engine in engines): + raise ValueError(f"{snapshot_path} has no extract engine") + return engines + + +def typed_dict(name: str, params: list[Param]) -> list[str]: + lines = [f"{name} = TypedDict(", f' "{name}",', " {"] + for param in params: + wrapper = "Required" if param.required else "NotRequired" + lines.append(f' "{param.name}": {wrapper}[{param.typ}],') + lines.extend([" },", " total=False,", ")", ""]) + return lines + + +def with_output(params: list[Param], *, text: bool) -> list[Param]: + output = Param("output", TEXT_OUTPUT, True) if text else Param("output", JSON_OUTPUT, False) + return sorted([*params, output], key=lambda param: param.name) + + +def engine_dict_params(engine: Engine, *, engine_required: bool) -> list[Param]: + return [*engine.params, Param("engine", literal([engine.name]), engine_required)] + + +def build_engine_params_stub(engines: list[Engine]) -> str: + lines = [ + HEADER, + "from typing import Union", + "from typing_extensions import Literal, NotRequired, Required, TypedDict, TypeAlias", + "", + '_Flag: TypeAlias = Union[bool, Literal[0, 1, "0", "1", "true", "false"]]', + "_Number: TypeAlias = Union[int, float, str]", + "_Scalar: TypeAlias = Union[str, int, float]", + "", + ] + for engine in engines: + params = engine_dict_params(engine, engine_required=engine.engine_required) + lines.extend(typed_dict(engine.json_params, with_output(params, text=False))) + lines.extend(typed_dict(engine.text_params, with_output(params, text=True))) + lines.append(f"{engine.search_params}: TypeAlias = Union[{engine.json_params}, {engine.text_params}]") + lines.append("") + + extract = next(engine for engine in engines if engine.name == "extract") + extract_params = engine_dict_params(extract, engine_required=False) + lines.extend(typed_dict("ExtractJsonParams", with_output(extract_params, text=False))) + lines.extend(typed_dict("ExtractTextParams", with_output(extract_params, text=True))) + lines.append("ExtractParams: TypeAlias = Union[ExtractJsonParams, ExtractTextParams]") + lines.append("") + + archive = list(ARCHIVE_PARAMS) + lines.extend(typed_dict("SearchArchiveJsonParams", with_output(archive, text=False))) + lines.extend(typed_dict("SearchArchiveTextParams", with_output(archive, text=True))) + lines.append("SearchArchiveParams: TypeAlias = Union[SearchArchiveJsonParams, SearchArchiveTextParams]") + lines.append("") + + lines.append("SearchParams: TypeAlias = Union[") + lines.extend(f" {engine.search_params}," for engine in engines) + lines.extend(["]", ""]) + return "\n".join(lines) + + +def request_option_params() -> list[Param]: + return [Param(name, typ, False) for name, typ in REQUEST_OPTIONS] + + +def keyword_params(params: list[Param], *, text: bool) -> list[Param] | None: + if any(param.required and not is_keyword_argument(param.name) for param in params): + return None + usable = [ + param + for param in params + if is_keyword_argument(param.name) and param.name not in REQUEST_OPTION_NAMES + ] + usable = with_output(usable, text=text) + request_option_params() + return sorted(usable, key=lambda param: (not param.required, param.name)) + + +def overload(function: str, receiver: str | None, params: list[str], return_type: str) -> list[str]: + lines = ["@overload", f"def {function}("] + if receiver: + lines.append(f" {receiver},") + lines.extend(f" {param}," for param in params) + lines.append(f") -> {return_type}: ...") + return lines + + +def keyword_overloads(function: str, receiver: str | None, params: list[Param]) -> list[str]: + lines: list[str] = [] + for text, return_type in ((True, "str"), (False, "SerpResults")): + kw_params = keyword_params(params, text=text) + if kw_params is None: + continue + rendered = ["params: None = None", "*"] + rendered.extend(f"{param.name}: {param.typ}" + ("" if param.required else " = ...") for param in kw_params) + lines.extend(overload(function, receiver, rendered, return_type)) + return lines + + +def mapping_overloads(function: str, receiver: str | None, json_type: str, text_type: str) -> list[str]: + options = ["*"] + [f"{name}: {typ} = ..." for name, typ in REQUEST_OPTIONS] + lines = overload(function, receiver, [f"params: {text_type}", *options], "str") + lines.extend(overload(function, receiver, [f"params: {json_type}", *options], "SerpResults")) + return lines + + +def fallback_overload(function: str, receiver: str | None, params_type: str) -> list[str]: + return overload(function, receiver, [f"params: {params_type}", "**kwargs: Any"], FALLBACK_RETURN) + + +def search_overloads(engines: list[Engine], receiver: str | None) -> list[str]: + lines: list[str] = [] + for engine in engines: + lines.extend(mapping_overloads("search", receiver, engine.json_params, engine.text_params)) + lines.extend(keyword_overloads("search", receiver, [*engine.params, Param("engine", literal([engine.name]), True)])) + if not engine.engine_required: + lines.extend(keyword_overloads("search", receiver, list(engine.params))) + lines.extend(fallback_overload("search", receiver, f"Union[SearchParams, {MUTABLE_PARAMS}]")) + return lines + + +def extract_overloads(extract: Engine, receiver: str | None) -> list[str]: + lines = mapping_overloads("extract", receiver, "ExtractJsonParams", "ExtractTextParams") + lines.extend(keyword_overloads("extract", receiver, list(extract.params))) + lines.extend(fallback_overload("extract", receiver, "Mapping[str, Any]")) + return lines + + +def archive_overloads(receiver: str | None) -> list[str]: + lines = mapping_overloads("search_archive", receiver, "SearchArchiveJsonParams", "SearchArchiveTextParams") + lines.extend(keyword_overloads("search_archive", receiver, list(ARCHIVE_PARAMS))) + lines.extend(fallback_overload("search_archive", receiver, f"Union[SearchArchiveParams, {MUTABLE_PARAMS}]")) + return lines + + +def other_functions(receiver: str | None) -> list[str]: + prefix = f"{receiver}, " if receiver else "" + options = ", ".join(f"{name}: {typ} = ..." for name, typ in REQUEST_OPTIONS) + return [ + f"def upload_image({prefix}image: Union[str, PathLike[str], IO[bytes]], *, {options}, **kwargs: Any) -> Dict[str, Any]: ...", + f"def locations({prefix}params: Optional[{MUTABLE_PARAMS}] = None, **kwargs: Any) -> List[Dict[str, Any]]: ...", + f"def account({prefix}params: Optional[{MUTABLE_PARAMS}] = None, **kwargs: Any) -> Dict[str, Any]: ...", + ] + + +def functions(engines: list[Engine], receiver: str | None) -> list[str]: + extract = next(engine for engine in engines if engine.name == "extract") + return [ + *search_overloads(engines, receiver), + *extract_overloads(extract, receiver), + *archive_overloads(receiver), + *other_functions(receiver), + ] + + +def build_core_stub(engines: list[Engine]) -> str: + imported = [name for engine in engines for name in (engine.json_params, engine.text_params)] + imported += [ + "ExtractJsonParams", + "ExtractTextParams", + "SearchArchiveJsonParams", + "SearchArchiveParams", + "SearchArchiveTextParams", + "SearchParams", + "_Flag", + "_Number", + "_Scalar", + ] + lines = [ + HEADER, + "from os import PathLike", + "from typing import IO, Any, Dict, List, Mapping, MutableMapping, Optional, Union, overload", + "from typing_extensions import Literal", + "", + "from .engine_params import (", + *(f" {name}," for name in sorted(imported)), + ")", + "from .http import HTTPClient, _Cert, _Proxies, _Timeout, _Verify", + "from .models import SerpResults", + "", + "class Client(HTTPClient):", + " DASHBOARD_URL: str", + " def __init__(self, *, api_key: Optional[str] = None, timeout: _Timeout = None) -> None: ...", + " def __repr__(self) -> str: ...", + ] + lines.extend(f" {line}" for line in functions(engines, "self")) + lines.append("") + lines.extend(functions(engines, None)) + lines.append("") + return "\n".join(lines) + + +def render(snapshot_path: Path = SNAPSHOT_PATH) -> dict[str, str]: + engines = load_engines(snapshot_path) + outputs = {"core.pyi": build_core_stub(engines), "engine_params.pyi": build_engine_params_stub(engines)} + for name, content in outputs.items(): + ast.parse(content, filename=name) + return outputs + + +def write(outputs: dict[str, str], output_dir: Path = OUTPUT_DIR) -> list[Path]: + written = [] + for name in GENERATED_FILES: + path = output_dir / name + if path.exists() and path.read_text(encoding="utf-8") == outputs[name]: + continue + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text(outputs[name], encoding="utf-8", newline="\n") + written.append(path) + return written + + +def stale_files(outputs: dict[str, str], output_dir: Path = OUTPUT_DIR) -> list[Path]: + stale = [] + for name in GENERATED_FILES: + path = output_dir / name + if not path.exists() or path.read_text(encoding="utf-8") != outputs[name]: + stale.append(path) + return stale + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--snapshot", type=Path, default=SNAPSHOT_PATH) + parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR) + parser.add_argument("--check", action="store_true", help="fail if generated stubs are out of date") + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + args = parse_args(sys.argv[1:] if argv is None else argv) + outputs = render(args.snapshot) + if args.check: + stale = stale_files(outputs, args.output_dir) + for path in stale: + print(f"Generated stub is out of date: {path}", file=sys.stderr) + if stale: + print("Run `python stubs/tools/generate_stubs.py` and commit the result.", file=sys.stderr) + return 1 + print("Generated stubs are up to date.") + return 0 + written = write(outputs, args.output_dir) + print(f"Wrote {len(written)} generated stub file(s) to {args.output_dir}") + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/stubs/tools/release_version.py b/stubs/tools/release_version.py new file mode 100644 index 0000000..bf9d7d0 --- /dev/null +++ b/stubs/tools/release_version.py @@ -0,0 +1,115 @@ +#!/usr/bin/env python3 +"""Compute and write the next serpapi-stubs version: .[.].""" + +from __future__ import annotations + +import argparse +import datetime +import json +import os +import re +import sys +from pathlib import Path +from typing import Iterable +from urllib.error import HTTPError +from urllib.request import Request, urlopen + +STUBS_ROOT = Path(__file__).resolve().parent.parent +SDK_VERSION_FILE = STUBS_ROOT.parent / "serpapi" / "__version__.py" +VERSION_FILE = STUBS_ROOT / "VERSION" +PYPI_JSON_URL = "https://pypi.org/pypi/serpapi-stubs/json" +FINAL_RELEASE = re.compile(r"[0-9]+\.[0-9]+\.[0-9]+") + + +def read_sdk_version(path: Path = SDK_VERSION_FILE) -> str: + match = re.search(r"""^__version__\s*=\s*["']([^"']+)["']""", path.read_text(encoding="utf-8"), re.MULTILINE) + if not match: + raise ValueError(f"Could not find __version__ in {path}") + version = match.group(1) + if not FINAL_RELEASE.fullmatch(version): + raise ValueError( + f"SDK version {version!r} is not a final X.Y.Z release such as 1.2.0; " + "serpapi-stubs versions append a date segment and only follow final SDK releases." + ) + return version + + +def next_version(sdk_version: str, date: datetime.date, existing: Iterable[str]) -> str: + published = set(existing) + base = f"{sdk_version}.{date:%Y%m%d}" + if base not in published: + return base + serial = 1 + while f"{base}.{serial}" in published: + serial += 1 + return f"{base}.{serial}" + + +def has_published_series(sdk_version: str, existing: Iterable[str]) -> bool: + prefix = f"{sdk_version}." + return any(version.startswith(prefix) for version in existing) + + +def published_versions(url: str = PYPI_JSON_URL) -> set[str]: + request = Request(url, headers={"Accept": "application/json"}) + try: + with urlopen(request, timeout=30) as response: + payload = json.load(response) + except HTTPError as error: + if error.code == 404: + return set() + raise + return set(payload["releases"]) + + +def parse_date(value: str) -> datetime.date: + return datetime.datetime.strptime(value, "%Y%m%d").date() + + +def series_check(tag: str) -> int: + """For an SDK release tag: verify it names the SDK version and report whether its stubs still need publishing.""" + sdk_version = read_sdk_version() + if tag != f"v{sdk_version}": + print(f"Release tag {tag!r} does not match SDK version tag 'v{sdk_version}'", file=sys.stderr) + return 1 + # A stub-only release may already have published this series; an SDK tag must not supersede it. + publish = not has_published_series(sdk_version, published_versions()) + print(f"{'Publishing' if publish else 'Skipping'} stubs for SDK {sdk_version}") + github_output = os.environ.get("GITHUB_OUTPUT") + if github_output: + with open(github_output, "a", encoding="utf-8") as handle: + handle.write(f"publish={'true' if publish else 'false'}\n") + return 0 + + +def parse_args(argv: list[str]) -> argparse.Namespace: + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--date", type=parse_date, help="release date as YYYYMMDD (default: today in UTC)") + parser.add_argument("--offline", action="store_true", help="do not query PyPI for existing versions") + parser.add_argument("--output", type=Path, default=VERSION_FILE, help="file that setuptools reads the version from") + parser.add_argument("--sdk-version", action="store_true", help="print the SDK version and exit") + parser.add_argument( + "--series-check", + metavar="TAG", + help="check an SDK release tag and write publish=true/false to GITHUB_OUTPUT instead of a version", + ) + return parser.parse_args(argv) + + +def main(argv: list[str] | None = None) -> int: + args = parse_args(sys.argv[1:] if argv is None else argv) + if args.sdk_version: + print(read_sdk_version()) + return 0 + if args.series_check is not None: + return series_check(args.series_check) + date = args.date or datetime.datetime.now(datetime.timezone.utc).date() + existing = set() if args.offline else published_versions() + version = next_version(read_sdk_version(), date, existing) + args.output.write_text(version + "\n", encoding="utf-8") + print(version) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/tests/test_typing_extra.py b/tests/test_typing_extra.py new file mode 100644 index 0000000..f3fc3c0 --- /dev/null +++ b/tests/test_typing_extra.py @@ -0,0 +1,9 @@ +import re +from pathlib import Path + +from serpapi import __version__ + + +def test_typing_extra_pins_stubs_to_sdk_release_series(): + pyproject = (Path(__file__).resolve().parents[1] / "pyproject.toml").read_text() + assert re.findall(r"^typing = \[(.*)\]$", pyproject, re.MULTILINE) == [f'"serpapi-stubs=={__version__}.*"'] From f7c2b3e570d44476d7b461352d70f3fa7e470f5c Mon Sep 17 00:00:00 2001 From: Adarsh Divakaran Date: Mon, 16 Nov 2026 00:56:24 +0530 Subject: [PATCH 2/4] CI: set up Python with uv in the test matrices ubuntu-latest is now Ubuntu 26.04, where actions/setup-python has no Python 3.8 or 3.9. uv downloads its own builds of every version in the matrix. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .github/workflows/ci.yml | 8 ++++---- .github/workflows/release.yml | 5 +++-- 2 files changed, 7 insertions(+), 6 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 8d19c8e..5f3f584 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,14 +21,14 @@ jobs: - name: Checkout repository uses: actions/checkout@v6 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v6 + - name: Set up uv with Python ${{ matrix.python-version }} + uses: astral-sh/setup-uv@v7 with: python-version: ${{ matrix.python-version }} - + activate-environment: true - name: Install dependencies - run: pip install -e .[test] + run: uv pip install -e '.[test]' - name: Run tests run: pytest tests --ignore-glob='tests/test_docs_*.py' -k "not example" diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 4bdb238..46b0921 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -30,12 +30,13 @@ jobs: echo "Release must run against a tag, got '${{ github.ref }}'" >&2 exit 1 - - uses: actions/setup-python@v6 + - uses: astral-sh/setup-uv@v7 with: python-version: ${{ matrix.python-version }} + activate-environment: true - name: Install dependencies - run: pip install -e .[test] + run: uv pip install -e '.[test]' - name: Run tests run: pytest --ignore=tests/test_docs_publishing.py -k "not example" From 8d6180f233e5a09c7ef25bae5dec163b1266d39e Mon Sep 17 00:00:00 2001 From: Adarsh Divakaran Date: Tue, 17 Nov 2026 12:36:21 +0530 Subject: [PATCH 3/4] fix: harden stub typing and release workflows Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .github/workflows/release.yml | 23 +- .github/workflows/stubs-build.yml | 32 + .github/workflows/stubs-refresh.yml | 39 +- .github/workflows/stubs-release.yml | 58 +- .github/workflows/stubs.yml | 4 + CONTRIBUTING.md | 18 +- stubs/README.md | 5 +- stubs/data/engines.json | 1902 ++++++------------------- stubs/serpapi-stubs/core.pyi | 106 +- stubs/serpapi-stubs/engine_params.pyi | 8 +- stubs/serpapi-stubs/http.pyi | 3 +- stubs/tests/test_fetch_engines.py | 28 +- stubs/tests/test_generate_stubs.py | 74 +- stubs/tests/test_packaging.py | 127 ++ stubs/tests/test_release_version.py | 37 +- stubs/tests/typecheck/check_errors.py | 4 +- stubs/tests/typecheck/check_usage.py | 28 +- stubs/tools/fetch_engines.py | 25 +- stubs/tools/generate_stubs.py | 16 +- stubs/tools/release_version.py | 28 +- 20 files changed, 994 insertions(+), 1571 deletions(-) create mode 100644 .github/workflows/stubs-build.yml diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 46b0921..5cd341f 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -96,26 +96,7 @@ jobs: name: Build stub distribution needs: [test, stubs-check, stubs-series] if: needs.stubs-series.outputs.publish == 'true' - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v6 - - - uses: actions/setup-python@v6 - with: - python-version: "3.13" - - - name: Build sdist and wheel - working-directory: stubs - run: | - pip install build - python tools/release_version.py - python -m build - - - uses: actions/upload-artifact@v7 - with: - name: stubs-dist - path: stubs/dist/ - if-no-files-found: error + uses: ./.github/workflows/stubs-build.yml # Stubs are published first so that `serpapi[typing]` resolves as soon as the SDK is available. publish-stubs: @@ -142,7 +123,7 @@ jobs: path: dist/ - id: final-check - name: Do not supersede an existing stub series + name: Do not supersede an installable stub series run: python stubs/tools/release_version.py --series-check "$GITHUB_REF_NAME" - name: Publish to PyPI diff --git a/.github/workflows/stubs-build.yml b/.github/workflows/stubs-build.yml new file mode 100644 index 0000000..660948d --- /dev/null +++ b/.github/workflows/stubs-build.yml @@ -0,0 +1,32 @@ +name: Build serpapi-stubs + +# Builds the stub distribution under its next release version and uploads it as the `stubs-dist` artifact. +on: + workflow_call: + +permissions: + contents: read + +jobs: + build: + name: Build stub distribution + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + + - uses: actions/setup-python@v6 + with: + python-version: "3.13" + + - name: Build sdist and wheel + working-directory: stubs + run: | + pip install build + python tools/release_version.py + python -m build + + - uses: actions/upload-artifact@v7 + with: + name: stubs-dist + path: stubs/dist/ + if-no-files-found: error diff --git a/.github/workflows/stubs-refresh.yml b/.github/workflows/stubs-refresh.yml index 82f5896..4b71da9 100644 --- a/.github/workflows/stubs-refresh.yml +++ b/.github/workflows/stubs-refresh.yml @@ -44,10 +44,29 @@ jobs: env: GH_TOKEN: ${{ secrets.STUBS_REFRESH_TOKEN || github.token }} run: | + bot="github-actions[bot]" + # Ignore fork PRs that happen to use the same branch name. open_pr=$(gh pr list --head "$BRANCH" --state open --json number,isCrossRepository \ --jq '[.[] | select(.isCrossRepository | not)][0].number // empty') + # A maintainer may have pushed fixes to the open refresh branch. Never discard those. An open pull + # request always has its branch, so a failed fetch is an error and has to stop the run. + branch_tip="" + human_commits=false + if [ -n "$open_pr" ]; then + git fetch --quiet --depth=1 origin "$BRANCH" + branch_tip=$(git rev-parse FETCH_HEAD) + if [ "$(git log -1 --format='%an/%cn' "$branch_tip")" != "$bot/$bot" ]; then + human_commits=true + fi + fi + + if [ "$human_commits" = true ]; then + echo "::warning::origin/$BRANCH has commits that this workflow did not make, so pull request #$open_pr was left unchanged." + exit 0 + fi + if [ -z "$(git status --porcelain -- stubs/)" ]; then echo "Stubs are up to date." if [ -n "$open_pr" ]; then @@ -57,24 +76,26 @@ jobs: exit 0 fi - git config user.name "github-actions[bot]" + git config user.name "$bot" git config user.email "41898282+github-actions[bot]@users.noreply.github.com" git switch -C "$BRANCH" git add stubs/ git commit -m "Refresh serpapi-stubs from the SerpApi playground" - if [ -z "$open_pr" ]; then + if [ -n "$open_pr" ]; then + # Leave the branch and its checks alone when it already has these stubs, whatever else changed + # on the default branch. + if [ "$(git rev-parse 'HEAD:stubs')" = "$(git rev-parse "$branch_tip:stubs")" ]; then + echo "Pull request #$open_pr already has these stubs." + exit 0 + fi + # The lease rejects the push if the branch changed after it was fetched above. + git push --force-with-lease="$BRANCH:$branch_tip" origin "$BRANCH" + else # Without an open PR the remote branch is left over from a merged or closed one. Updating it # would carry every change made to the default branch since then, and GitHub can refuse a # push that changes workflow files that way, so start from a fresh branch. git push --quiet origin --delete "$BRANCH" 2>/dev/null || true - fi - - # Do not rewrite the refresh branch (or rerun its checks) when it already has these stubs. - if git fetch --quiet --depth=1 origin "$BRANCH" 2>/dev/null \ - && [ "$(git rev-parse 'HEAD^{tree}')" = "$(git rev-parse 'FETCH_HEAD^{tree}')" ]; then - echo "origin/$BRANCH already has these stubs." - else git push --force origin "$BRANCH" fi diff --git a/.github/workflows/stubs-release.yml b/.github/workflows/stubs-release.yml index 78d8b6b..669d313 100644 --- a/.github/workflows/stubs-release.yml +++ b/.github/workflows/stubs-release.yml @@ -16,6 +16,7 @@ on: concurrency: group: serpapi-stubs-release cancel-in-progress: false + queue: max permissions: contents: read @@ -51,7 +52,7 @@ jobs: fi tag="v$version" if ! git rev-parse --verify --quiet "refs/tags/$tag" >/dev/null; then - echo "::notice::$tag is not tagged yet; these stubs will ship with the SDK release." + echo "::notice::$tag is not tagged yet; include these stubs in the SDK release or rerun this workflow after tagging." echo "release=false" >> "$GITHUB_OUTPUT" elif ! git diff --quiet "$tag" HEAD -- serpapi/; then echo "::notice::serpapi/ changed since $tag; these stubs will ship with the next SDK release." @@ -68,26 +69,7 @@ jobs: build: name: Build serpapi-stubs needs: [check] - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v6 - - - uses: actions/setup-python@v6 - with: - python-version: "3.13" - - - name: Build sdist and wheel - working-directory: stubs - run: | - pip install build - python tools/release_version.py - python -m build - - - uses: actions/upload-artifact@v7 - with: - name: stubs-dist - path: stubs/dist/ - if-no-files-found: error + uses: ./.github/workflows/stubs-build.yml publish: name: Publish serpapi-stubs @@ -97,12 +79,46 @@ jobs: name: pypi-stubs url: https://pypi.org/p/serpapi-stubs permissions: + contents: read id-token: write steps: + - uses: actions/checkout@v6 + with: + fetch-depth: 0 + + # Re-running an older run would publish that commit's stubs under a newer version. This runs in the + # publishing job because "Re-run failed jobs" keeps the outputs of the jobs that already passed. + - id: current + name: Do not supersede newer stubs for the same SDK + run: | + git fetch --quiet origin "refs/heads/$GITHUB_REF_NAME" + if ! git merge-base --is-ancestor HEAD FETCH_HEAD; then + echo "::notice::$GITHUB_REF_NAME no longer contains this commit; skipping the replaced run." + echo "publish=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + + # Only a newer shipped-stub change for this SDK can replace this release. Look through history, + # because the branch tip may already target an unreleased SDK. Keep these paths with on.push.paths. + stub_paths=( + stubs/serpapi-stubs stubs/pyproject.toml stubs/MANIFEST.in stubs/LICENSE stubs/README.md + ) + commits=$(git rev-list --first-parent HEAD..FETCH_HEAD -- "${stub_paths[@]}") + for commit in $commits; do + if git diff --quiet HEAD "$commit" -- serpapi/; then + echo "::notice::Newer compatible stub change $commit supersedes this run; use that commit's run to release." + echo "publish=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + done + echo "publish=true" >> "$GITHUB_OUTPUT" + - uses: actions/download-artifact@v8 + if: steps.current.outputs.publish == 'true' with: name: stubs-dist path: dist/ - name: Publish to PyPI + if: steps.current.outputs.publish == 'true' uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.github/workflows/stubs.yml b/.github/workflows/stubs.yml index 51680c7..5349942 100644 --- a/.github/workflows/stubs.yml +++ b/.github/workflows/stubs.yml @@ -6,12 +6,16 @@ on: paths: - "serpapi/**" - "stubs/**" + - "pyproject.toml" + - "LICENSE" - ".github/workflows/stubs*.yml" pull_request: branches: [master] paths: - "serpapi/**" - "stubs/**" + - "pyproject.toml" + - "LICENSE" - ".github/workflows/stubs*.yml" workflow_call: diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 6adce44..44c0a5b 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -182,12 +182,14 @@ python tools/generate_stubs.py --check python -m pytest python tools/release_version.py --offline uv build --clear -uv pip install mypy pyright --reinstall-package serpapi-stubs dist/*.whl +uv pip install "mypy==2.4.1" "pyright==1.1.414" --reinstall-package serpapi-stubs dist/*.whl python -m mypy.stubtest serpapi --allowlist tests/stubtest_allowlist.txt mypy pyright ``` +The checker versions are the ones the workflow pins; change both together. + `release_version.py` writes the ignored `VERSION` file that the build reads. Stub versions are computed in CI, so never set them by hand. Stubtest fails when a public SDK function or class changes without a matching stub change, so update the handwritten stubs in `stubs/serpapi-stubs/` together with the SDK. ### Stub releases @@ -197,15 +199,19 @@ Stubs are published in two ways: - **With an SDK release.** The release workflow publishes `serpapi-stubs` `.` before it publishes the SDK, so `serpapi[typing]` resolves as soon as the SDK is available. - **Between SDK releases.** When a push to `master` changes the shipped stub files, the [stub release workflow](.github/workflows/stubs-release.yml) publishes a new version for the current SDK release. It skips publishing if `serpapi/__version__.py` names a version that has not been tagged or if `serpapi/` changed since that tag. Those stubs ship with the next SDK release instead. -The [refresh workflow](.github/workflows/stubs-refresh.yml) runs every Monday. It fetches the engine metadata, regenerates the stubs, and opens or updates a pull request from `bot/refresh-serpapi-stubs` when anything changed. If a later run finds that the stubs match `master` again, it closes that pull request. A manual run also refreshes from `master`, whichever branch it is started on. Review the diff before merging: merging usually publishes a stub release. +The [refresh workflow](.github/workflows/stubs-refresh.yml) runs every Monday. It fetches the engine metadata, regenerates the stubs, and opens or updates a pull request from `bot/refresh-serpapi-stubs` when anything changed. If a later run finds that the stubs match `master` again, it closes that pull request. A manual run also refreshes from `master`, whichever branch it is started on. Review the diff before merging: merging usually publishes a stub release. If you push your own commits to the refresh branch, later runs leave the branch and its pull request unchanged until it is merged or closed. + +GitHub can refuse a push that carries workflow-file changes from `master` into an existing branch. The workflow avoids most of these pushes: it recreates a leftover refresh branch, and it updates an open refresh pull request only when the generated stubs changed. If a run still fails to push for that reason, merge or close the pull request and run the workflow again. + +If a stub release breaks valid code, yank it on PyPI and merge a fix. The SDK-tag workflow does not supersede a series with any non-yanked files. If the series has only yanked releases or no files left, it publishes a replacement before the SDK. Yanked and file-less versions still reserve their version numbers. For an upload collision between simultaneous stub releases, choose **Re-run all jobs** on the latest compatible run of the stub-only release workflow. It computes the next available date suffix, whereas **Re-run failed jobs** reuses the colliding version. -GitHub can refuse a push that carries workflow-file changes from `master` into an existing branch. The workflow avoids that by recreating a leftover refresh branch, but it cannot do so while the refresh pull request is open. If a run fails to push for that reason, merge or close the pull request and run the workflow again. +The stub-only workflow queues up to 100 pending runs across release branches, rather than letting a hotfix or manual dispatch replace an already pending release. Before uploading, it checks the branch's first-parent history: a newer shipped-stub change for the same SDK supersedes an older run, but a change targeting an unreleased SDK does not suppress the last compatible release. A run whose commit was removed from the branch is also skipped. After a cancellation or a full queue, rerun all jobs on the newest compatible run, not an older superseded one. -If a stub release breaks valid code, yank it on PyPI and merge a fix. The SDK-tag workflow publishes a stub series only once, so rerunning an old SDK tag cannot supersede a newer stub-only release with the tag's older stub files. For an upload collision between simultaneous stub releases, choose **Re-run all jobs** on the stub-only release workflow. It computes the next available date suffix, whereas **Re-run failed jobs** reuses the colliding version. +Release tags publish only the files in the tagged commit. If a stub change was skipped while waiting for a tag but landed after that commit, manually run **Release serpapi-stubs** on `master` once the tag exists, provided `serpapi/` still matches it. If SDK development has moved on, use the hotfix procedure below instead. -The stub version scheme currently supports final numeric SDK versions only, such as `1.2.3`. Prerelease, post-release, and development SDK versions cannot be published with the `serpapi-stubs` date suffix or the `serpapi[typing]` exact-series pin. +The stub version scheme currently supports final numeric SDK versions only, such as `1.2.3`. Prerelease, post-release, and development SDK versions cannot be published with the `serpapi-stubs` date suffix or the `serpapi[typing]` exact-series pin. Do not set `serpapi/__version__.py` to one: the stub checks then fail on every pull request, and the release workflow stops before it publishes the SDK. -If a stub fix is needed after `serpapi/` has changed for an unreleased SDK version, the automatic workflow correctly skips it. To hotfix the released SDK, create a compatibility branch from its tag, bring over only the corrected `stubs/` content and the current `stubs.yml` and `stubs-release.yml` workflows, and keep `serpapi/` unchanged from the tag. Push it as `stubs/hotfix-` and manually run **Release serpapi-stubs** on that branch; the workflow only runs from `master` or from the hotfix branch named after the SDK version it contains. Add `stubs/hotfix-*` as an allowed branch for the `pypi-stubs` environment before dispatching. +If a stub fix is needed after `serpapi/` has changed for an unreleased SDK version, the automatic workflow correctly skips it. To hotfix the released SDK, create a compatibility branch from its tag, bring over only the corrected `stubs/` content and the current `stubs.yml`, `stubs-build.yml`, `stubs-release.yml`, and `stubs-refresh.yml` workflows, and keep `serpapi/` unchanged from the tag. The refresh workflow is needed by the stub tests even when you do not run it. Push it as `stubs/hotfix-` and manually run **Release serpapi-stubs** on that branch; the workflow only runs from `master` or from the hotfix branch named after the SDK version it contains. Add `stubs/hotfix-*` as an allowed branch for the `pypi-stubs` environment before dispatching. ### Stub maintainer setup diff --git a/stubs/README.md b/stubs/README.md index 92fb16e..b226e77 100644 --- a/stubs/README.md +++ b/stubs/README.md @@ -55,12 +55,13 @@ Notes: - `async` and `from` are Python keywords, so pass them in the params dict: `client.search({"engine": "google", "q": "coffee", "async": True})`. - In keyword calls, `timeout` is the HTTP request timeout. Pass Extract's API `timeout` parameter in the params dict. - Keyword calls need literal `engine` and `output` values so the checker can select the engine's overload. A `str` variable, or `**` unpacking of a `Dict[str, str]`, is rejected. When either value is computed at runtime, pass a params dict, or type the value as `Literal` or `Final`. +- A `dict` variable that is not annotated with a parameter type gives a `SerpResults | Any` result, because the checker cannot see its `output` value. Pass `output="md"` or `output="html"` as a keyword to get `str`, or `output="json"` to get `SerpResults`. The keyword overrides any `output` in the mapping. - `search()`, `search_archive()`, `locations()`, and `account()` write the API key into the mapping they receive, so pass a `dict` or a `serpapi.engine_params` type. A read-only `Mapping` or your own `TypedDict` is rejected; pass `dict(params)` instead. `extract()` copies its mapping and accepts any `Mapping`. - Pyright reports `reportMissingModuleSource` for `serpapi.engine_params` because the module has no runtime source. Importing it under `TYPE_CHECKING` is safe. Engine parameters come from the [SerpApi Playground](https://serpapi.com/playground). Parameters that SerpApi has not documented there are reported as errors. Use a `# type: ignore` comment or an untyped `dict` if you need one. Parameters that the Playground gives no type accept `str`, `int`, or `float`, because the SDK sends numbers as text. -The Playground sometimes uses UI-specific values rather than the API values (for example, Amazon language choices combine a domain and locale). The stubs normalize those choices to the API's documented locale codes. A parameter is typed as a closed set of options only when the Playground presents it as a single-choice list whose spelling matches its documentation. Parameters that document case-insensitive values (such as Bing's `mkt`, `cc`, and `safeSearch`) or comma-separated values (such as Tripadvisor Reviews' `type_of_visit`) are typed `str`. When an engine parameter is not present in the Playground, pass a mapping to `search()`; mapping calls remain compatible with runtime-supported parameters without weakening keyword checks. +The Playground sometimes uses UI-specific values rather than the API values (for example, Amazon language choices combine a domain and locale). The stubs normalize those choices to the API's documented locale codes. A parameter is typed as a closed set of options only when the Playground presents it as a single-choice list that agrees with its documentation. Parameters that document case-insensitive values (such as Bing's `mkt`, `cc`, and `safeSearch`), comma-separated values (such as Tripadvisor Reviews' `type_of_visit`), or a value missing from the list (such as Yandex's `sort_mode`) are typed `str`. When an engine parameter is not present in the Playground, pass a mapping to `search()`; mapping calls remain compatible with runtime-supported parameters without weakening keyword checks. ## Versions @@ -76,7 +77,7 @@ A stub update can add, remove, or narrow parameters as SerpApi engines change. T pip install "serpapi[typing]" "serpapi-stubs==1.2.0.20260715" ``` -A stub release that breaks valid code is yanked from PyPI and fixed in a newer release. If a fix is needed after `serpapi/` has changed for an unreleased SDK version, prepare a compatibility hotfix branch from the affected SDK tag. Bring over the corrected `stubs/` files and the current `stubs.yml` and `stubs-release.yml` workflows, but keep `serpapi/` identical to the tag. Push the branch as `stubs/hotfix-` and manually run **Release serpapi-stubs** on that branch. Add the `stubs/hotfix-*` branch rule to the `pypi-stubs` environment before dispatching; the workflow still verifies that the branch name and the SDK source match the tag. +A stub release that breaks valid code is yanked from PyPI and fixed in a newer release. ## Development diff --git a/stubs/data/engines.json b/stubs/data/engines.json index 99cee34..3467a48 100644 --- a/stubs/data/engines.json +++ b/stubs/data/engines.json @@ -11,9 +11,7 @@ "value_type": "string" }, "amenities": {}, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bathrooms": { "type": "number" @@ -103,9 +101,7 @@ "ZAR" ] }, - "engine": { - "required": true - }, + "engine": {}, "guest_favorite": { "type": "checkbox" }, @@ -179,9 +175,7 @@ "amazon.com.mx" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "dc": { "type": "checkbox" @@ -197,9 +191,7 @@ ] }, "emi": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "k": {}, "language": { @@ -362,17 +354,11 @@ "amazon.com.mx" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, - "k": { - "required": true - }, + "k": {}, "no_cache": { "type": "checkbox" }, @@ -390,16 +376,12 @@ "amazon.com" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "dc": { "type": "checkbox" }, - "delivery_zip": { - "required": true - }, + "delivery_zip": {}, "device": { "type": "device", "options": [ @@ -408,9 +390,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "k": {}, "language": { @@ -479,12 +459,8 @@ "amazon.com.mx" ] }, - "api_key": { - "required": true - }, - "asin": { - "required": true - }, + "api_key": {}, + "asin": {}, "async": {}, "delivery_city": {}, "delivery_zip": {}, @@ -496,9 +472,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "language": { "type": "select", @@ -579,9 +553,7 @@ "amazon.com.mx" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -591,9 +563,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "include_products": { "type": "checkbox" }, @@ -641,15 +611,11 @@ "type": "checkbox" }, "output": {}, - "promotion_id": { - "required": true - }, + "promotion_id": {}, "zero_trace": {} }, "apple_app_store": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_id": { "type": "select", @@ -670,9 +636,7 @@ "disallow_explicit": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lang": { "type": "select", @@ -731,20 +695,14 @@ "developer" ] }, - "term": { - "required": true - }, + "term": {}, "zero_trace": {} }, "apple_maps": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "center": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "locale": { "type": "select", @@ -812,9 +770,7 @@ "type": "number" }, "output": {}, - "query": { - "required": true - }, + "query": {}, "sort": { "type": "select", "options": [ @@ -828,13 +784,9 @@ "zero_trace": {} }, "apple_maps_places": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "locale": { "type": "select", @@ -891,9 +843,7 @@ "zh-TW" ] }, - "muid": { - "required": true - }, + "muid": {}, "no_cache": { "type": "checkbox" }, @@ -901,25 +851,19 @@ "zero_trace": {} }, "apple_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", "value_type": "string" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, + "product_id": {}, "type": { "type": "select", "options": [ @@ -929,17 +873,13 @@ "zero_trace": {} }, "apple_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", "value_type": "string" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -948,9 +888,7 @@ "page": { "type": "number" }, - "product_id": { - "required": true - }, + "product_id": {}, "sort": { "type": "select", "options": [ @@ -963,13 +901,9 @@ "zero_trace": {} }, "autozone": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "facet": {}, "include_filters": { "type": "checkbox" @@ -991,9 +925,7 @@ "ps": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "sort": { "type": "select", "options": [ @@ -1022,21 +954,15 @@ "zero_trace": {} }, "autozone_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, + "product_id": {}, "store_id": {}, "vehicle_engine": {}, "vehicle_make": {}, @@ -1055,9 +981,7 @@ "zero_trace": {} }, "baidu": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bs": {}, "ct": { @@ -1072,9 +996,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "f": {}, "gpc": {}, "json_restrictor": {}, @@ -1086,9 +1008,7 @@ "pn": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "q5": {}, "q6": {}, "rn": { @@ -1097,17 +1017,13 @@ "zero_trace": {} }, "baidu_maps": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "c": { "type": "select", "value_type": "number" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lat": { "type": "number" @@ -1122,23 +1038,17 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "baidu_news": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "ct": { "type": "select", "value_type": "number" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "medium": { "type": "select", @@ -1151,9 +1061,7 @@ "pn": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "rn": { "type": "number" }, @@ -1164,9 +1072,7 @@ "zero_trace": {} }, "bing": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cc": { "type": "select", @@ -1180,9 +1086,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filters": {}, "first": { "type": "number" @@ -1205,9 +1109,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safeSearch": { "type": "select", "value_type": "string" @@ -1215,13 +1117,9 @@ "zero_trace": {} }, "bing_copilot": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lat": { "type": "number" @@ -1236,9 +1134,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "bing_images": { @@ -1251,9 +1147,7 @@ "lt525600" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "aspect": { "type": "select", "options": [ @@ -1297,9 +1191,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "face": { "type": "select", "options": [ @@ -1351,9 +1243,7 @@ "shopping" ] }, - "q": { - "required": true - }, + "q": {}, "safeSearch": { "type": "select", "options": [ @@ -1365,17 +1255,13 @@ "zero_trace": {} }, "bing_maps": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "count": { "type": "number" }, "cp": {}, - "engine": { - "required": true - }, + "engine": {}, "first": { "type": "number" }, @@ -1385,9 +1271,7 @@ }, "output": {}, "place_id": {}, - "q": { - "required": true - }, + "q": {}, "setlang": { "type": "select", "options": [ @@ -1446,9 +1330,7 @@ "zero_trace": {} }, "bing_news": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cc": { "type": "select", @@ -1465,9 +1347,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "first": { "type": "number" }, @@ -1480,9 +1360,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "qft": { "type": "select", "options": [ @@ -1500,27 +1378,19 @@ "zero_trace": {} }, "bing_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_token": { - "required": true - }, + "product_token": {}, "zero_trace": {} }, "bing_reverse_image": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cab": { "type": "number" @@ -1537,12 +1407,8 @@ "count": { "type": "number" }, - "engine": { - "required": true - }, - "image_url": { - "required": true - }, + "engine": {}, + "image_url": {}, "json_restrictor": {}, "mkt": { "type": "select", @@ -1556,9 +1422,7 @@ "zero_trace": {} }, "bing_shopping": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cc": { "type": "select", @@ -1575,9 +1439,7 @@ "efirst": { "type": "number" }, - "engine": { - "required": true - }, + "engine": {}, "filters": {}, "json_restrictor": {}, "mkt": { @@ -1588,15 +1450,11 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "bing_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cc": { "type": "select", @@ -1619,9 +1477,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "first": { "type": "number" }, @@ -1649,9 +1505,7 @@ "paid" ] }, - "q": { - "required": true - }, + "q": {}, "resolution": { "type": "select", "options": [ @@ -1739,9 +1593,7 @@ "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "check_in_date": {}, "check_out_date": {}, @@ -1761,9 +1613,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "flex_window": { "type": "select", "value_type": "number" @@ -1841,9 +1691,7 @@ }, "output": {}, "property_types": {}, - "q": { - "required": true - }, + "q": {}, "rating": { "type": "select", "value_type": "number" @@ -1872,9 +1720,7 @@ "zero_trace": {} }, "brave": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", @@ -1920,9 +1766,7 @@ "us" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "language": { "type": "select", @@ -1988,9 +1832,7 @@ "type": "number" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe_search": { "type": "select", "options": [ @@ -2006,9 +1848,7 @@ "zero_trace": {} }, "brave_ai_mode": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", @@ -2053,9 +1893,7 @@ "us" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "language": { "type": "select", @@ -2118,9 +1956,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safeSearch": { "type": "select", "options": [ @@ -2140,9 +1976,7 @@ "zero_trace": {} }, "brave_images": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", @@ -2187,17 +2021,13 @@ "us" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe_search": { "type": "select", "options": [ @@ -2212,9 +2042,7 @@ "zero_trace": {} }, "brave_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", @@ -2268,9 +2096,7 @@ "past_year" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -2279,9 +2105,7 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "safe_search": { "type": "select", "options": [ @@ -2296,19 +2120,13 @@ "zero_trace": {} }, "doordash": { - "address": { - "required": true - }, - "api_key": { - "required": true - }, + "address": {}, + "api_key": {}, "async": {}, "deals": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "fastest": { "type": "checkbox" }, @@ -2327,9 +2145,7 @@ "pickup": { "type": "checkbox" }, - "q": { - "required": true - }, + "q": {}, "store_type": { "type": "select", "options": [ @@ -2345,13 +2161,9 @@ "zero_trace": {} }, "duck_ai": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "model": { "type": "select", @@ -2369,21 +2181,15 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "subsequent_request_token": {}, "zero_trace": {} }, "duckduckgo": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "df": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "kl": { "type": "select", @@ -2461,9 +2267,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "value_type": "number" @@ -2477,14 +2281,10 @@ "zero_trace": {} }, "duckduckgo_light": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "df": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "kl": { "type": "select", @@ -2560,20 +2360,14 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "duckduckgo_maps": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bbox": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lat": { "type": "number" @@ -2585,9 +2379,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "strict_bbox": { "type": "select", "value_type": "number" @@ -2595,14 +2387,10 @@ "zero_trace": {} }, "duckduckgo_news": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "df": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "kl": { "type": "select", @@ -2680,9 +2468,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "value_type": "number" @@ -2693,13 +2479,9 @@ "zero_trace": {} }, "duckduckgo_shopping": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "filters": {}, "json_restrictor": {}, "kl": { @@ -2758,9 +2540,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "sort_by": { "type": "select", "value_type": "number" @@ -2774,7 +2554,8 @@ "value_type": "number" }, "_blrs": { - "type": "checkbox" + "type": "checkbox", + "value_type": "string" }, "_dmd": { "type": "select", @@ -2784,9 +2565,7 @@ "type": "select", "value_type": "number" }, - "_nkw": { - "required": true - }, + "_nkw": {}, "_pgn": { "type": "number" }, @@ -2810,9 +2589,7 @@ "_udlo": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "buying_format": { "type": "select", @@ -2844,9 +2621,7 @@ "ebay.com" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -2857,9 +2632,7 @@ "zero_trace": {} }, "ebay_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "ebay_domain": { "type": "select", @@ -2882,9 +2655,7 @@ "ebay.com" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lang": { "type": "select", @@ -2898,9 +2669,7 @@ "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, + "product_id": {}, "shipping_country": { "type": "select", "value_type": "string" @@ -2920,9 +2689,7 @@ "type": "select", "value_type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "buying_format": { "type": "select", @@ -2949,9 +2716,7 @@ "ebay.com" ] }, - "engine": { - "required": true - }, + "engine": {}, "free_shipping": { "type": "checkbox" }, @@ -2960,12 +2725,9 @@ "type": "checkbox" }, "output": {}, - "seller_id": { - "required": true - }, + "seller_id": {}, "type": { "type": "select", - "required": true, "options": [ "user", "store" @@ -2974,9 +2736,7 @@ "zero_trace": {} }, "eventbrite": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category": { "type": "select", @@ -3017,9 +2777,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "event_type": { "type": "select", "options": [ @@ -3077,9 +2835,7 @@ "zero_trace": {} }, "extract": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -3089,9 +2845,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "exclude_tags": {}, "include_markdown": { "type": "checkbox" @@ -3128,15 +2882,11 @@ "timeout": { "type": "number" }, - "url": { - "required": true - }, + "url": {}, "zero_trace": {} }, "facebook_marketplace": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "availability": { "type": "select", @@ -3179,9 +2929,7 @@ "shipping" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lat": { "type": "number" @@ -3220,37 +2968,27 @@ "zero_trace": {} }, "facebook_profile": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "profile_id": { - "required": true - }, + "profile_id": {}, "zero_trace": {} }, "flightradar24": { "aircraft_type": {}, "airline": {}, "airport": {}, - "api_key": { - "required": true - }, + "api_key": {}, "arrival_id": {}, "async": {}, "callsign": {}, "departure_id": {}, - "engine": { - "required": true - }, + "engine": {}, "flight_number": {}, "json_restrictor": {}, "map_bounds": {}, @@ -3262,13 +3000,9 @@ "zero_trace": {} }, "glassdoor_companies": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "location": {}, "min_rating": { @@ -3286,9 +3020,7 @@ "zero_trace": {} }, "glassdoor_jobs": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "date_posted": { "type": "select", @@ -3298,9 +3030,7 @@ "type": "checkbox" }, "employer_id": {}, - "engine": { - "required": true - }, + "engine": {}, "job_type": { "type": "select", "options": [ @@ -3347,20 +3077,14 @@ "zero_trace": {} }, "glassdoor_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "current_employees": { "type": "checkbox" }, - "employer_id": { - "required": true - }, + "employer_id": {}, "employment_status": {}, - "engine": { - "required": true - }, + "engine": {}, "job_title": {}, "json_restrictor": {}, "language": { @@ -3404,9 +3128,7 @@ "zero_trace": {} }, "google": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -3473,9 +3195,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "radius": { "type": "number" }, @@ -3512,13 +3232,9 @@ "zero_trace": {} }, "google_about_this_result": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3542,9 +3258,7 @@ "zero_trace": {} }, "google_ads": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -3554,17 +3268,14 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" }, "json_restrictor": {}, "location": { - "type": "location", - "required": true + "type": "location" }, "nfpr": { "type": "checkbox" @@ -3573,9 +3284,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -3587,9 +3296,7 @@ }, "google_ads_transparency_center": { "advertiser_id": {}, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "creative_format": { "type": "dropdown", @@ -3600,9 +3307,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "get_advertiser": { "type": "checkbox" }, @@ -3637,19 +3342,11 @@ "zero_trace": {} }, "google_ads_transparency_center_ad_details": { - "advertiser_id": { - "required": true - }, - "api_key": { - "required": true - }, + "advertiser_id": {}, + "api_key": {}, "async": {}, - "creative_id": { - "required": true - }, - "engine": { - "required": true - }, + "creative_id": {}, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -3662,9 +3359,7 @@ "zero_trace": {} }, "google_ai_mode": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "continuable": { "type": "checkbox" @@ -3677,9 +3372,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3697,35 +3390,25 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "subsequent_request_token": {}, "uule": {}, "zero_trace": {} }, "google_ai_overview": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "page_token": { - "required": true - }, + "page_token": {}, "zero_trace": {} }, "google_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "client": { "type": "select", @@ -3742,9 +3425,7 @@ ] }, "cp": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3758,15 +3439,11 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_books": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -3785,9 +3462,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3808,9 +3483,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "start": { "type": "number" }, @@ -3826,16 +3499,10 @@ "zero_trace": {} }, "google_event_details": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, - "event_token": { - "required": true - }, + "engine": {}, + "event_token": {}, "gl": { "type": "select", "value_type": "string" @@ -3861,13 +3528,9 @@ "zero_trace": {} }, "google_events": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "location": { "type": "location" @@ -3876,20 +3539,14 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "uule": {}, "zero_trace": {} }, "google_finance": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -3899,9 +3556,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "window": { "type": "dropdown", "options": [ @@ -3918,13 +3573,9 @@ "zero_trace": {} }, "google_finance_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3938,19 +3589,13 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_finance_markets": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -3966,7 +3611,6 @@ "output": {}, "trend": { "type": "select", - "required": true, "options": [ "indexes" ] @@ -3977,9 +3621,7 @@ "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "arrival_id": {}, "async": {}, "bags": { @@ -4074,9 +3716,7 @@ "type": "select", "value_type": "number" }, - "engine": { - "required": true - }, + "engine": {}, "exclude_airlines": {}, "exclude_basic": { "type": "checkbox" @@ -4137,13 +3777,9 @@ "zero_trace": {} }, "google_flights_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "exclude_regions": { "type": "checkbox" }, @@ -4160,21 +3796,15 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_flights_calendar": { "adults": { "type": "number" }, - "api_key": { - "required": true - }, - "arrival_id": { - "required": true - }, + "api_key": {}, + "arrival_id": {}, "async": {}, "children": { "type": "number" @@ -4257,12 +3887,8 @@ }, "date_range_end": {}, "date_range_start": {}, - "departure_id": { - "required": true - }, - "engine": { - "required": true - }, + "departure_id": {}, + "engine": {}, "fixed_outbound_date": { "type": "checkbox" }, @@ -4302,9 +3928,7 @@ "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "children": { "type": "number" @@ -4386,9 +4010,7 @@ ] }, "departure_id": {}, - "engine": { - "required": true - }, + "engine": {}, "exclude_airlines": {}, "gl": { "type": "select", @@ -4439,9 +4061,7 @@ "zero_trace": {} }, "google_forums": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -4452,9 +4072,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -4492,9 +4110,7 @@ "period_value": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "start": { "type": "number" }, @@ -4504,21 +4120,15 @@ "zero_trace": {} }, "google_gemini": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "subsequent_request_token": {}, "zero_trace": {} }, @@ -4527,9 +4137,7 @@ "type": "number" }, "amenities": {}, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bathrooms": { "type": "number" @@ -4538,12 +4146,8 @@ "type": "number" }, "brands": {}, - "check_in_date": { - "required": true - }, - "check_out_date": { - "required": true - }, + "check_in_date": {}, + "check_out_date": {}, "children": { "type": "number" }, @@ -4627,9 +4231,7 @@ "eco_certified": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "free_cancellation": { "type": "checkbox" }, @@ -4656,9 +4258,7 @@ "output": {}, "property_token": {}, "property_types": {}, - "q": { - "required": true - }, + "q": {}, "rating": { "type": "select", "value_type": "number" @@ -4676,9 +4276,7 @@ "zero_trace": {} }, "google_hotels_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "currency": { "type": "select", @@ -4756,9 +4354,7 @@ "VND" ] }, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -4772,37 +4368,27 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_hotels_photos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "next_page_token": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "property_token": { - "required": true - }, + "property_token": {}, "zero_trace": {} }, "google_hotels_price_calendar": { "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "children": { "type": "number" @@ -4884,12 +4470,8 @@ "VND" ] }, - "end_date": { - "required": true - }, - "engine": { - "required": true - }, + "end_date": {}, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -4903,23 +4485,15 @@ "type": "checkbox" }, "output": {}, - "property_token": { - "required": true - }, - "start_date": { - "required": true - }, + "property_token": {}, + "start_date": {}, "zero_trace": {} }, "google_hotels_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_token": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -4930,9 +4504,7 @@ "type": "checkbox" }, "output": {}, - "property_token": { - "required": true - }, + "property_token": {}, "sort_by": { "type": "select", "value_type": "number" @@ -4943,9 +4515,7 @@ "zero_trace": {} }, "google_images": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -4969,9 +4539,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -5087,9 +4655,7 @@ "period_value": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -5103,9 +4669,7 @@ "zero_trace": {} }, "google_images_light": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -5128,9 +4692,7 @@ ] }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -5243,9 +4805,7 @@ "period_value": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -5262,13 +4822,9 @@ "zero_trace": {} }, "google_images_related_content": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5283,19 +4839,13 @@ }, "output": {}, "q": {}, - "related_content_id": { - "required": true - }, + "related_content_id": {}, "zero_trace": {} }, "google_immersive_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "more_stores": { "type": "checkbox" @@ -5305,20 +4855,14 @@ "type": "checkbox" }, "output": {}, - "page_token": { - "required": true - }, + "page_token": {}, "zero_trace": {} }, "google_jobs": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "chips": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5346,35 +4890,25 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "uds": {}, "uule": {}, "zero_trace": {} }, "google_jobs_listing": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_lens": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "auto_crop": { "type": "checkbox" @@ -5383,9 +4917,7 @@ "type": "select", "value_type": "string" }, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -5408,22 +4940,17 @@ }, "type": { "type": "select", - "required": true, "options": [ "all", "exact_matches", "visual_matches" ] }, - "url": { - "required": true - }, + "url": {}, "zero_trace": {} }, "google_light": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -5444,9 +4971,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -5474,9 +4999,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -5491,9 +5014,7 @@ "zero_trace": {} }, "google_local": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -5503,9 +5024,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5527,9 +5046,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "start": { "type": "number" }, @@ -5538,9 +5055,7 @@ "zero_trace": {} }, "google_local_services": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bid": { "type": "number" @@ -5549,12 +5064,9 @@ "type": "number" }, "data_cid": { - "type": "number", - "required": true - }, - "engine": { - "required": true + "type": "number" }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -5573,21 +5085,16 @@ }, "q": { "type": "select", - "required": true, "value_type": "string" }, "zero_trace": {} }, "google_maps": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "data": {}, "data_cid": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5661,7 +5168,6 @@ }, "type": { "type": "select", - "required": true, "options": [ "search", "place" @@ -5673,14 +5179,10 @@ "zero_trace": {} }, "google_maps_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cp": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5690,29 +5192,19 @@ "value_type": "string" }, "json_restrictor": {}, - "ll": { - "required": true - }, + "ll": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_maps_contributor_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "contributor_id": { - "required": true - }, - "engine": { - "required": true - }, + "contributor_id": {}, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5732,9 +5224,7 @@ "zero_trace": {} }, "google_maps_directions": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "avoid": {}, "distance_unit": { @@ -5744,9 +5234,7 @@ "end_addr": {}, "end_coords": {}, "end_data_id": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5776,16 +5264,10 @@ "zero_trace": {} }, "google_maps_photo_meta": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "data_id": { - "required": true - }, - "engine": { - "required": true - }, + "data_id": {}, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -5794,17 +5276,11 @@ "zero_trace": {} }, "google_maps_photos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_id": {}, - "data_id": { - "required": true - }, - "engine": { - "required": true - }, + "data_id": {}, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -5818,16 +5294,10 @@ "zero_trace": {} }, "google_maps_posts": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "data_id": { - "required": true - }, - "engine": { - "required": true - }, + "data_id": {}, + "engine": {}, "json_restrictor": {}, "next_page_token": {}, "no_cache": { @@ -5837,14 +5307,10 @@ "zero_trace": {} }, "google_maps_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "data_id": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -5871,13 +5337,9 @@ "zero_trace": {} }, "google_news": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -5904,9 +5366,7 @@ "zero_trace": {} }, "google_news_light": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -5927,9 +5387,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -5957,9 +5415,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -5975,9 +5431,7 @@ }, "google_patents": { "after": {}, - "api_key": { - "required": true - }, + "api_key": {}, "assignee": {}, "async": {}, "before": {}, @@ -5994,9 +5448,7 @@ "language" ] }, - "engine": { - "required": true - }, + "engine": {}, "inventor": {}, "json_restrictor": {}, "language": {}, @@ -6048,21 +5500,15 @@ "zero_trace": {} }, "google_patents_details": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "patent_id": { - "required": true - }, + "patent_id": {}, "zero_trace": {} }, "google_play": { @@ -6074,9 +5520,7 @@ "AGE_RANGE3" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "apps_category": { "type": "select", "options": [ @@ -6119,9 +5563,7 @@ }, "async": {}, "chart": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -6161,18 +5603,14 @@ "AGE_RANGE3" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "books_category": { "type": "select", "value_type": "string" }, "chart": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -6197,14 +5635,10 @@ "zero_trace": {} }, "google_play_games": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "chart": {}, - "engine": { - "required": true - }, + "engine": {}, "games_category": { "type": "select", "options": [ @@ -6267,14 +5701,10 @@ "AGE_RANGE3" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "chart": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -6302,13 +5732,9 @@ "all_reviews": { "type": "checkbox" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -6337,9 +5763,7 @@ "car" ] }, - "product_id": { - "required": true - }, + "product_id": {}, "rating": { "type": "select", "value_type": "number" @@ -6351,7 +5775,6 @@ }, "store": { "type": "select", - "required": true, "options": [ "apps", "movies", @@ -6363,13 +5786,9 @@ "zero_trace": {} }, "google_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "options": [ @@ -6466,17 +5885,11 @@ "zero_trace": {} }, "google_related_questions": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, - "next_page_token": { - "required": true - }, + "next_page_token": {}, "no_cache": { "type": "checkbox" }, @@ -6484,9 +5897,7 @@ "zero_trace": {} }, "google_reverse_image": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -6496,9 +5907,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -6511,9 +5920,7 @@ "type": "select", "value_type": "string" }, - "image_url": { - "required": true - }, + "image_url": {}, "json_restrictor": {}, "location": { "type": "location" @@ -6539,9 +5946,7 @@ "zero_trace": {} }, "google_scholar": { - "api_key": { - "required": true - }, + "api_key": {}, "as_rr": { "type": "checkbox" }, @@ -6558,9 +5963,7 @@ "async": {}, "cites": {}, "cluster": {}, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -6577,9 +5980,7 @@ "type": "number" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -6597,17 +5998,11 @@ "zero_trace": {} }, "google_scholar_author": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "author_id": { - "required": true - }, + "author_id": {}, "citation_id": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -6640,16 +6035,10 @@ "zero_trace": {} }, "google_scholar_case_law": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "case_id": { - "required": true - }, - "engine": { - "required": true - }, + "case_id": {}, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -6658,13 +6047,9 @@ "zero_trace": {} }, "google_scholar_cite": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -6674,15 +6059,11 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_shopping": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -6703,9 +6084,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "free_shipping": { "type": "checkbox" }, @@ -6813,9 +6192,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -6838,13 +6215,9 @@ "zero_trace": {} }, "google_shopping_filters": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "options": [ @@ -6940,17 +6313,13 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "shoprs": {}, "uule": {}, "zero_trace": {} }, "google_shopping_light": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -6960,9 +6329,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "free_shipping": { "type": "checkbox" }, @@ -7070,9 +6437,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -7095,9 +6460,7 @@ "zero_trace": {} }, "google_short_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -7118,9 +6481,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -7148,9 +6509,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -7166,13 +6525,9 @@ "zero_trace": {} }, "google_sports": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -7182,9 +6537,7 @@ "value_type": "string" }, "json_restrictor": {}, - "kgmid": { - "required": true - }, + "kgmid": {}, "moa": {}, "mob": {}, "mpd": {}, @@ -7195,7 +6548,6 @@ "season_kgmid": {}, "sp": { "type": "select", - "required": true, "options": [ "ft", "bs", @@ -7220,7 +6572,6 @@ }, "type": { "type": "select", - "required": true, "options": [ "game", "league", @@ -7230,16 +6581,11 @@ "zero_trace": {} }, "google_translate": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "from": { "type": "select", - "required": true, "value_type": "string" }, "json_restrictor": {}, @@ -7247,12 +6593,9 @@ "type": "checkbox" }, "output": {}, - "text": { - "required": true - }, + "text": {}, "to": { "type": "select", - "required": true, "value_type": "string" }, "zero_trace": {} @@ -7261,9 +6604,7 @@ "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "arrival_area_id": {}, "arrival_id": {}, "async": {}, @@ -7349,12 +6690,8 @@ "VND" ] }, - "departure_id": { - "required": true - }, - "engine": { - "required": true - }, + "departure_id": {}, + "engine": {}, "exclude_airlines": {}, "gl": { "type": "select", @@ -7412,9 +6749,7 @@ "zero_trace": {} }, "google_trends": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cat": { "type": "select", @@ -7434,9 +6769,7 @@ ] }, "date": {}, - "engine": { - "required": true - }, + "engine": {}, "geo": {}, "gprop": { "type": "select", @@ -7460,9 +6793,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "region": { "type": "select", "options": [ @@ -7478,13 +6809,9 @@ "zero_trace": {} }, "google_trends_autocomplete": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "value_type": "string" @@ -7494,33 +6821,23 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "zero_trace": {} }, "google_trends_news": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "page_token": { - "required": true - }, + "page_token": {}, "zero_trace": {} }, "google_trends_trending_now": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cat": { "type": "select", @@ -7539,12 +6856,9 @@ "value_type": "number" }, "date": {}, - "engine": { - "required": true - }, + "engine": {}, "frequency": { "type": "select", - "required": true, "options": [ "daily", "realtime" @@ -7552,7 +6866,6 @@ }, "geo": { "type": "select", - "required": true, "value_type": "number" }, "hl": { @@ -7574,9 +6887,7 @@ "zero_trace": {} }, "google_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -7597,9 +6908,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -7627,9 +6936,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -7645,9 +6952,7 @@ "zero_trace": {} }, "google_videos_light": { - "api_key": { - "required": true - }, + "api_key": {}, "as_dt": {}, "as_epq": {}, "as_eq": {}, @@ -7668,9 +6973,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "filter": { "type": "checkbox" }, @@ -7698,9 +7001,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "safe": { "type": "select", "options": [ @@ -7716,9 +7017,7 @@ "zero_trace": {} }, "home_depot": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "country": { "type": "select", @@ -7728,9 +7027,7 @@ ] }, "delivery_zip": {}, - "engine": { - "required": true - }, + "engine": {}, "filter": {}, "hd_filter_tokens": {}, "hd_sort": { @@ -7760,9 +7057,7 @@ "ps": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "sort": { "type": "select", "options": [ @@ -7780,14 +7075,10 @@ "zero_trace": {} }, "home_depot_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "delivery_zip": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -7799,22 +7090,16 @@ "zero_trace": {} }, "home_depot_product_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, "pagesize": {}, - "product_id": { - "required": true - }, + "product_id": {}, "rating": {}, "sort_by": { "type": "select", @@ -7835,13 +7120,9 @@ "zero_trace": {} }, "indeed_jobs": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "fromage": { "type": "select", "value_type": "number" @@ -7862,9 +7143,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "radius": { "type": "select", "value_type": "number" @@ -7878,17 +7157,11 @@ "zero_trace": {} }, "instagram_popular": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, - "keyword": { - "required": true - }, + "keyword": {}, "next_page_token": {}, "no_cache": { "type": "checkbox" @@ -7897,22 +7170,16 @@ "zero_trace": {} }, "instagram_profile": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "next_page_token": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "profile_id": { - "required": true - }, + "profile_id": {}, "zero_trace": {} }, "meta_ad_library": { @@ -7934,9 +7201,7 @@ "financial_products_and_services_ads" ] }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "content_languages": {}, "country": { @@ -7944,9 +7209,7 @@ "value_type": "string" }, "end_date": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "media_type": { "type": "select", @@ -7986,13 +7249,9 @@ "zero_trace": {} }, "napa": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -8001,9 +7260,7 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "sort": { "type": "select", "options": [ @@ -8019,9 +7276,7 @@ "zero_trace": {} }, "naver": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -8031,9 +7286,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -8044,9 +7297,7 @@ "output": {}, "page": {}, "period": {}, - "query": { - "required": true - }, + "query": {}, "sort_by": { "type": "select", "value_type": "number" @@ -8065,31 +7316,23 @@ "zero_trace": {} }, "naver_ai_mode": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "continuable": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "query": { - "required": true - }, + "query": {}, "subsequent_request_token": {}, "zero_trace": {} }, "naver_ai_overview": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -8099,9 +7342,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -8115,9 +7356,7 @@ "adults": { "type": "number" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "bookable": { "type": "checkbox" @@ -8131,9 +7370,7 @@ "coupon": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "naver_pay": { "type": "checkbox" @@ -8151,9 +7388,7 @@ "page": { "type": "number" }, - "query": { - "required": true - }, + "query": {}, "sort_by": { "type": "select", "options": [ @@ -8166,13 +7401,9 @@ "zero_trace": {} }, "open_table_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -8203,19 +7434,13 @@ "page": { "type": "number" }, - "rid": { - "required": true - }, + "rid": {}, "zero_trace": {} }, "pinterest": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "less_ai": { "type": "checkbox" @@ -8225,9 +7450,7 @@ "type": "checkbox" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "type": { "type": "select", "options": [ @@ -8241,15 +7464,11 @@ "zero_trace": {} }, "search_index": { - "api_key": { - "required": true - }, + "api_key": {}, "as_yhi": {}, "as_ylo": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -8283,9 +7502,7 @@ "home_depot" ] }, - "q": { - "required": true - }, + "q": {}, "radius": { "type": "number" }, @@ -8312,15 +7529,11 @@ "zero_trace": {} }, "target": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_id": {}, "delivery_zip": {}, - "engine": { - "required": true - }, + "engine": {}, "facet": {}, "include_filters": { "type": "checkbox" @@ -8339,9 +7552,7 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "sort": { "type": "select", "options": [ @@ -8361,13 +7572,9 @@ "zero_trace": {} }, "tiktok_discover": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -8380,9 +7587,7 @@ "type": "number" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "session_token": {}, "start": { "type": "number" @@ -8390,18 +7595,14 @@ "zero_trace": {} }, "tiktok_shop": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_id": {}, "color_id": {}, "deals": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "max_price": { "type": "number" @@ -8416,9 +7617,7 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "rating": { "type": "select", "value_type": "number" @@ -8434,17 +7633,13 @@ "zero_trace": {} }, "trader_joes": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_id": { "type": "number" }, "characteristics": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "new_products": { "type": "checkbox" @@ -8456,9 +7651,7 @@ "page": { "type": "number" }, - "q": { - "required": true - }, + "q": {}, "sort_by": { "type": "select", "options": [ @@ -8474,32 +7667,22 @@ "zero_trace": {} }, "trader_joes_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, + "product_id": {}, "store_id": {}, "zero_trace": {} }, "tripadvisor": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "lat": { "type": "number" @@ -8517,9 +7700,7 @@ "type": "number" }, "output": {}, - "q": { - "required": true - }, + "q": {}, "ssrc": { "type": "select", "options": [ @@ -8589,21 +7770,15 @@ "zero_trace": {} }, "tripadvisor_place": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "place_id": { - "required": true - }, + "place_id": {}, "tripadvisor_domain": { "type": "select", "options": [ @@ -8661,13 +7836,9 @@ "zero_trace": {} }, "tripadvisor_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "language": { "type": "select", @@ -8708,9 +7879,7 @@ }, "offset": {}, "output": {}, - "place_id": { - "required": true - }, + "place_id": {}, "rating": {}, "sort_by": { "type": "select", @@ -8779,9 +7948,7 @@ "zero_trace": {} }, "walmart": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "cat_id": {}, "device": { @@ -8792,9 +7959,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "facet": {}, "include_filters": { "type": "checkbox" @@ -8816,9 +7981,7 @@ "page": { "type": "number" }, - "query": { - "required": true - }, + "query": {}, "soft_sort": { "type": "checkbox" }, @@ -8846,9 +8009,7 @@ "zero_trace": {} }, "walmart_product": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -8858,28 +8019,20 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, + "product_id": {}, "store_id": {}, "zero_trace": {} }, "walmart_product_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" @@ -8888,9 +8041,7 @@ "page": { "type": "number" }, - "product_id": { - "required": true - }, + "product_id": {}, "rating": { "type": "select", "value_type": "number" @@ -8909,37 +8060,23 @@ "zero_trace": {} }, "walmart_product_sellers": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "product_id": { - "required": true - }, - "store_id": { - "required": true - }, + "product_id": {}, + "store_id": {}, "zero_trace": {} }, "walmart_seller": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "catalog_seller_id": { - "required": true - }, - "engine": { - "required": true - }, + "catalog_seller_id": {}, + "engine": {}, "facet": {}, "include_filters": { "type": "checkbox" @@ -8966,9 +8103,7 @@ "zero_trace": {} }, "yahoo": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "b": { "type": "number" @@ -8982,18 +8117,14 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "fr2": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "p": { - "required": true - }, + "p": {}, "vc": { "type": "select", "value_type": "string" @@ -9096,9 +8227,7 @@ "zero_trace": {} }, "yahoo_images": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "b": { "type": "number" @@ -9111,9 +8240,7 @@ "mobile" ] }, - "engine": { - "required": true - }, + "engine": {}, "imga": { "type": "select", "options": [ @@ -9193,9 +8320,7 @@ "type": "checkbox" }, "output": {}, - "p": { - "required": true - }, + "p": {}, "yahoo_domain": { "type": "select", "options": [ @@ -9228,14 +8353,10 @@ "zero_trace": {} }, "yahoo_shopping": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "category_attr_values": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "limit": {}, "max_price": {}, @@ -9252,9 +8373,7 @@ ] }, "output": {}, - "p": { - "required": true - }, + "p": {}, "page": {}, "sort_by": { "type": "select", @@ -9269,13 +8388,9 @@ "zero_trace": {} }, "yahoo_trends": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "full_video_links": { "type": "checkbox" }, @@ -9288,9 +8403,7 @@ "zero_trace": {} }, "yahoo_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "b": { "type": "number" @@ -9311,17 +8424,13 @@ "long" ] }, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "no_cache": { "type": "checkbox" }, "output": {}, - "p": { - "required": true - }, + "p": {}, "vage": { "type": "select", "options": [ @@ -9394,13 +8503,9 @@ "zero_trace": {} }, "yandex": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "family_mode": { "type": "select", "value_type": "number" @@ -9449,14 +8554,9 @@ }, "sort_mode": { "type": "select", - "options": [ - "relevance", - "time" - ] - }, - "text": { - "required": true + "value_type": "string" }, + "text": {}, "yandex_domain": { "type": "select", "options": [ @@ -9471,9 +8571,7 @@ "zero_trace": {} }, "yandex_images": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "color": { "type": "select", @@ -9495,9 +8593,7 @@ "crop_id": { "type": "number" }, - "engine": { - "required": true - }, + "engine": {}, "family_mode": { "type": "select", "value_type": "number" @@ -9550,9 +8646,7 @@ "similar" ] }, - "text": { - "required": true - }, + "text": {}, "url": {}, "width": { "type": "number" @@ -9571,9 +8665,7 @@ "zero_trace": {} }, "yandex_videos": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "device": { "type": "device", @@ -9591,9 +8683,7 @@ "long" ] }, - "engine": { - "required": true - }, + "engine": {}, "hd": { "type": "checkbox" }, @@ -9605,9 +8695,7 @@ "p": { "type": "number" }, - "text": { - "required": true - }, + "text": {}, "within": { "type": "select", "value_type": "number" @@ -9626,17 +8714,11 @@ "zero_trace": {} }, "yelp": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "find_desc": {}, - "find_loc": { - "required": true - }, + "find_loc": {}, "json_restrictor": {}, "next_page_token": {}, "no_cache": { @@ -9703,16 +8785,12 @@ "zero_trace": {} }, "yelp_place": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "business_alert": { "type": "checkbox" }, - "engine": { - "required": true - }, + "engine": {}, "full_menu": { "type": "checkbox" }, @@ -9722,9 +8800,7 @@ "type": "checkbox" }, "output": {}, - "place_id": { - "required": true - }, + "place_id": {}, "yelp_domain": { "type": "select", "options": [ @@ -9774,13 +8850,9 @@ "zero_trace": {} }, "yelp_reviews": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "hl": { "type": "select", "options": [ @@ -9818,9 +8890,7 @@ "type": "number" }, "output": {}, - "place_id": { - "required": true - }, + "place_id": {}, "q": {}, "rating": {}, "sortby": { @@ -9886,13 +8956,9 @@ "zero_trace": {} }, "youtube": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -9906,9 +8972,7 @@ "type": "checkbox" }, "output": {}, - "search_query": { - "required": true - }, + "search_query": {}, "sp": {}, "zero_trace": {} }, @@ -9916,14 +8980,10 @@ "about": { "type": "checkbox" }, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "channel_id": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -10045,13 +9105,9 @@ "zero_trace": {} }, "youtube_video": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "gl": { "type": "select", "value_type": "string" @@ -10070,13 +9126,9 @@ "zero_trace": {} }, "youtube_video_transcript": { - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, - "engine": { - "required": true - }, + "engine": {}, "json_restrictor": {}, "language_code": { "type": "select", @@ -10093,9 +9145,7 @@ "asr" ] }, - "v": { - "required": true - }, + "v": {}, "zero_trace": {} }, "zillow": { @@ -10108,16 +9158,12 @@ ] }, "amenities": {}, - "api_key": { - "required": true - }, + "api_key": {}, "async": {}, "basement": {}, "baths": {}, "beds": {}, - "engine": { - "required": true - }, + "engine": {}, "has_garage": { "type": "checkbox" }, diff --git a/stubs/serpapi-stubs/core.pyi b/stubs/serpapi-stubs/core.pyi index cb0e2f9..998c7ae 100644 --- a/stubs/serpapi-stubs/core.pyi +++ b/stubs/serpapi-stubs/core.pyi @@ -3042,7 +3042,7 @@ class Client(HTTPClient): output: Literal["html", "md"], LH_ItemCondition: _Scalar = ..., LH_PrefLoc: _Number = ..., - _blrs: _Flag = ..., + _blrs: str = ..., _dmd: _Number = ..., _ipg: _Number = ..., _nkw: _Scalar = ..., @@ -3077,7 +3077,7 @@ class Client(HTTPClient): engine: Literal["ebay"], LH_ItemCondition: _Scalar = ..., LH_PrefLoc: _Number = ..., - _blrs: _Flag = ..., + _blrs: str = ..., _dmd: _Number = ..., _ipg: _Number = ..., _nkw: _Scalar = ..., @@ -11832,7 +11832,7 @@ class Client(HTTPClient): p: _Number = ..., period: Literal["all", "day", "last_two_weeks", "month"] = ..., proxies: _Proxies = ..., - sort_mode: Literal["relevance", "time"] = ..., + sort_mode: str = ..., stream: Optional[bool] = ..., text: _Scalar = ..., timeout: _Timeout = ..., @@ -11859,7 +11859,7 @@ class Client(HTTPClient): p: _Number = ..., period: Literal["all", "day", "last_two_weeks", "month"] = ..., proxies: _Proxies = ..., - sort_mode: Literal["relevance", "time"] = ..., + sort_mode: str = ..., stream: Optional[bool] = ..., text: _Scalar = ..., timeout: _Timeout = ..., @@ -12620,6 +12620,22 @@ class Client(HTTPClient): zero_trace: _Flag = ..., ) -> SerpResults: ... @overload + def search( + self, + params: Union[SearchParams, MutableMapping[str, Any]], + *, + output: Literal["html", "md"], + **kwargs: Any, + ) -> str: ... + @overload + def search( + self, + params: Union[SearchParams, MutableMapping[str, Any]], + *, + output: Literal["json"], + **kwargs: Any, + ) -> SerpResults: ... + @overload def search( self, params: Union[SearchParams, MutableMapping[str, Any]], @@ -12702,6 +12718,22 @@ class Client(HTTPClient): zero_trace: _Flag = ..., ) -> SerpResults: ... @overload + def extract( + self, + params: Mapping[str, Any], + *, + output: Literal["html", "md"], + **kwargs: Any, + ) -> str: ... + @overload + def extract( + self, + params: Mapping[str, Any], + *, + output: Literal["json"], + **kwargs: Any, + ) -> SerpResults: ... + @overload def extract( self, params: Mapping[str, Any], @@ -12758,6 +12790,22 @@ class Client(HTTPClient): verify: _Verify = ..., ) -> SerpResults: ... @overload + def search_archive( + self, + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + *, + output: Literal["html", "md"], + **kwargs: Any, + ) -> str: ... + @overload + def search_archive( + self, + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + *, + output: Literal["json"], + **kwargs: Any, + ) -> SerpResults: ... + @overload def search_archive( self, params: Union[SearchArchiveParams, MutableMapping[str, Any]], @@ -15307,7 +15355,7 @@ def search( output: Literal["html", "md"], LH_ItemCondition: _Scalar = ..., LH_PrefLoc: _Number = ..., - _blrs: _Flag = ..., + _blrs: str = ..., _dmd: _Number = ..., _ipg: _Number = ..., _nkw: _Scalar = ..., @@ -15341,7 +15389,7 @@ def search( engine: Literal["ebay"], LH_ItemCondition: _Scalar = ..., LH_PrefLoc: _Number = ..., - _blrs: _Flag = ..., + _blrs: str = ..., _dmd: _Number = ..., _ipg: _Number = ..., _nkw: _Scalar = ..., @@ -23631,7 +23679,7 @@ def search( p: _Number = ..., period: Literal["all", "day", "last_two_weeks", "month"] = ..., proxies: _Proxies = ..., - sort_mode: Literal["relevance", "time"] = ..., + sort_mode: str = ..., stream: Optional[bool] = ..., text: _Scalar = ..., timeout: _Timeout = ..., @@ -23657,7 +23705,7 @@ def search( p: _Number = ..., period: Literal["all", "day", "last_two_weeks", "month"] = ..., proxies: _Proxies = ..., - sort_mode: Literal["relevance", "time"] = ..., + sort_mode: str = ..., stream: Optional[bool] = ..., text: _Scalar = ..., timeout: _Timeout = ..., @@ -24378,6 +24426,20 @@ def search( zero_trace: _Flag = ..., ) -> SerpResults: ... @overload +def search( + params: Union[SearchParams, MutableMapping[str, Any]], + *, + output: Literal["html", "md"], + **kwargs: Any, +) -> str: ... +@overload +def search( + params: Union[SearchParams, MutableMapping[str, Any]], + *, + output: Literal["json"], + **kwargs: Any, +) -> SerpResults: ... +@overload def search( params: Union[SearchParams, MutableMapping[str, Any]], **kwargs: Any, @@ -24455,6 +24517,20 @@ def extract( zero_trace: _Flag = ..., ) -> SerpResults: ... @overload +def extract( + params: Mapping[str, Any], + *, + output: Literal["html", "md"], + **kwargs: Any, +) -> str: ... +@overload +def extract( + params: Mapping[str, Any], + *, + output: Literal["json"], + **kwargs: Any, +) -> SerpResults: ... +@overload def extract( params: Mapping[str, Any], **kwargs: Any, @@ -24506,6 +24582,20 @@ def search_archive( verify: _Verify = ..., ) -> SerpResults: ... @overload +def search_archive( + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + *, + output: Literal["html", "md"], + **kwargs: Any, +) -> str: ... +@overload +def search_archive( + params: Union[SearchArchiveParams, MutableMapping[str, Any]], + *, + output: Literal["json"], + **kwargs: Any, +) -> SerpResults: ... +@overload def search_archive( params: Union[SearchArchiveParams, MutableMapping[str, Any]], **kwargs: Any, diff --git a/stubs/serpapi-stubs/engine_params.pyi b/stubs/serpapi-stubs/engine_params.pyi index e18c1cf..5366cbf 100644 --- a/stubs/serpapi-stubs/engine_params.pyi +++ b/stubs/serpapi-stubs/engine_params.pyi @@ -1711,7 +1711,7 @@ EbayJsonSearchParams = TypedDict( { "LH_ItemCondition": NotRequired[_Scalar], "LH_PrefLoc": NotRequired[_Number], - "_blrs": NotRequired[_Flag], + "_blrs": NotRequired[str], "_dmd": NotRequired[_Number], "_ipg": NotRequired[_Number], "_nkw": NotRequired[_Scalar], @@ -1744,7 +1744,7 @@ EbayTextSearchParams = TypedDict( { "LH_ItemCondition": NotRequired[_Scalar], "LH_PrefLoc": NotRequired[_Number], - "_blrs": NotRequired[_Flag], + "_blrs": NotRequired[str], "_dmd": NotRequired[_Number], "_ipg": NotRequired[_Number], "_nkw": NotRequired[_Scalar], @@ -7384,7 +7384,7 @@ YandexJsonSearchParams = TypedDict( "output": NotRequired[Literal["json"]], "p": NotRequired[_Number], "period": NotRequired[Literal["all", "day", "last_two_weeks", "month"]], - "sort_mode": NotRequired[Literal["relevance", "time"]], + "sort_mode": NotRequired[str], "text": NotRequired[_Scalar], "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], "zero_trace": NotRequired[_Flag], @@ -7408,7 +7408,7 @@ YandexTextSearchParams = TypedDict( "output": Required[Literal["html", "md"]], "p": NotRequired[_Number], "period": NotRequired[Literal["all", "day", "last_two_weeks", "month"]], - "sort_mode": NotRequired[Literal["relevance", "time"]], + "sort_mode": NotRequired[str], "text": NotRequired[_Scalar], "yandex_domain": NotRequired[Literal["yandex.com", "yandex.ru", "yandex.by", "yandex.kz", "yandex.uz", "yandex.com.tr"]], "zero_trace": NotRequired[_Flag], diff --git a/stubs/serpapi-stubs/http.pyi b/stubs/serpapi-stubs/http.pyi index 43d0616..2f3f4a2 100644 --- a/stubs/serpapi-stubs/http.pyi +++ b/stubs/serpapi-stubs/http.pyi @@ -4,7 +4,8 @@ import requests from typing_extensions import TypeAlias _Timeout: TypeAlias = Union[None, float, Tuple[Optional[float], Optional[float]]] -_Proxies: TypeAlias = Union[None, Mapping[str, str]] +# requests removes a proxy whose value is None, which is how one request opts out of a configured proxy. +_Proxies: TypeAlias = Union[None, Mapping[str, Optional[str]]] _Verify: TypeAlias = Union[None, bool, str] _Cert: TypeAlias = Union[None, str, Tuple[str, str]] diff --git a/stubs/tests/test_fetch_engines.py b/stubs/tests/test_fetch_engines.py index d43bd96..23b421d 100644 --- a/stubs/tests/test_fetch_engines.py +++ b/stubs/tests/test_fetch_engines.py @@ -6,8 +6,8 @@ import fetch_engines -def engine(*params, required=True): - group = {"engine": {"type": "select", "required": required}} +def engine(*params): + group = {"engine": {"type": "select"}} group.update({name: metadata for name, metadata in params}) return {"serpapi_parameters": {"name": "SerpApi", "parameters": group}} @@ -41,8 +41,9 @@ def test_extract_props_requires_parameters(): ("name", {"options": ["4.5", "-1.25"]}, None, {"value_type": "number"}), ("language", {"type": "select", "options": ["amazon.com|en_US", "amazon.co.uk|en_GB"]}, "amazon", {"type": "select", "options": ["en_US", "en_GB"]}), ("name", {"type": "select", "options": [[str(i) + "x", "x"] for i in range(fetch_engines.MAX_LITERAL_OPTIONS + 1)]}, None, {"type": "select", "value_type": "string"}), - ("name", {"type": "checkbox", "required": "true"}, None, {"type": "checkbox"}), - ("name", {"required": True, "options": [[True, "yes"]]}, None, {"required": True}), + # The playground's `required` flags are often conditional, so the snapshot does not keep them. + ("name", {"type": "checkbox", "required": True}, None, {"type": "checkbox"}), + ("name", {"options": [[True, "yes"]]}, None, {}), # Options without a closed-choice type, such as a comma-separated multi-value list, are open strings. ("type_of_visit", {"options": ["Business", "Couples"], "html": "Separate values with a comma"}, None, {"value_type": "string"}), ("name", {"type": "text", "options": ["a", "b"]}, None, {"type": "text", "value_type": "string"}), @@ -52,6 +53,12 @@ def test_extract_props_requires_parameters(): # Documented values that match exactly, or are unrelated to the options, keep the closed list. ("mkt", {"type": "select", "options": ["en-us", "de-de"], "html": "Use en-us or de-de"}, None, {"type": "select", "options": ["en-us", "de-de"]}), ("mkt", {"type": "select", "options": ["en-us", "de-de"], "html": "Defaults to all"}, None, {"type": "select", "options": ["en-us", "de-de"]}), + # A listed value that the options lack means the option list cannot be trusted. + ("sort_mode", {"type": "select", "options": ["relevance", "time"], "html": "relevance - by relevance
date - by date."}, None, {"type": "select", "value_type": "string"}), + ("tbm", {"type": "select", "options": ["isch", "vid"], "html": "(no selection) - regular search
isch - images"}, None, {"type": "select", "options": ["isch", "vid"]}), + ("sort_mode", {"type": "select", "options": ["relevance", "time"], "html": "relevance — by relevance
date – by date."}, None, {"type": "select", "value_type": "string"}), + # eBay's `_blrs` checkbox sends a value, not a flag. + ("_blrs", {"type": "checkbox"}, "ebay", {"type": "checkbox", "value_type": "string"}), ], ) def test_normalize_param(name, metadata, engine, expected): @@ -62,7 +69,7 @@ def test_normalize_props_sorts_and_excludes(few_engines): snapshot = fetch_engines.normalize_props( { "parameters": { - "google": engine(("q", {}), ("device", {"type": "select", "options": [["mobile", "Mobile"]]}), required=False), + "google": engine(("q", {}), ("device", {"type": "select", "options": [["mobile", "Mobile"]]})), "extract": engine(("url", {"required": True})), "google_light_fast": engine(), } @@ -71,16 +78,7 @@ def test_normalize_props_sorts_and_excludes(few_engines): assert list(snapshot["engines"]) == ["extract", "google"] assert list(snapshot["engines"]["google"]) == ["device", "engine", "q"] assert snapshot["engines"]["google"]["device"] == {"type": "select", "options": ["mobile"]} - assert snapshot["engines"]["google"]["engine"] == {"type": "select"} - - -def test_normalize_param_converts_amazon_language_options(): - language = fetch_engines.normalize_param( - "language", - {"type": "select", "options": ["amazon.com|en_US", "amazon.co.uk|en_GB"]}, - "amazon", - ) - assert language["options"] == ["en_US", "en_GB"] + assert snapshot["engines"]["extract"]["url"] == {} @pytest.mark.parametrize( diff --git a/stubs/tests/test_generate_stubs.py b/stubs/tests/test_generate_stubs.py index ef5420a..3af8fe1 100644 --- a/stubs/tests/test_generate_stubs.py +++ b/stubs/tests/test_generate_stubs.py @@ -1,5 +1,7 @@ import ast import json +import re +from pathlib import Path import pytest @@ -9,16 +11,16 @@ "engines": { "google": { "engine": {}, - "q": {"required": True}, + "q": {}, "device": {"type": "select", "options": ["desktop", "mobile"]}, "num": {"type": "number"}, "nfpr": {"type": "checkbox"}, "async": {}, }, - "google_lens": {"engine": {"required": True}, "url": {"required": True}, "image_id": {}}, - "google_translate": {"engine": {"required": True}, "from": {"required": True}, "text": {}}, - "naver": {"engine": {"required": True}, "page": {}, "start": {}, "num": {}}, - "extract": {"engine": {"required": True}, "url": {"required": True}, "timeout": {"type": "number"}}, + "google_lens": {"engine": {}, "url": {}, "image_id": {}}, + "google_translate": {"engine": {}, "from": {}, "text": {}}, + "naver": {"engine": {}, "page": {}, "start": {}, "num": {}}, + "extract": {"engine": {}, "url": {}, "timeout": {"type": "number"}}, } } @@ -57,40 +59,36 @@ def test_param_types(engines): [ # The SDK sends numbers as text, so a parameter the playground leaves untyped accepts them. ("min_price", {}, "_Scalar"), - ("store_id", {"required": True}, "_Scalar"), ("mkt", {"type": "select", "value_type": "string"}, "str"), ("location", {"type": "location"}, "str"), ("type_of_visit", {"value_type": "string"}, "str"), ("api_key", {}, "str"), ], ) -def test_untyped_params_accept_numbers(name, metadata, expected): +def test_only_untyped_params_accept_numbers(name, metadata, expected): assert generate_stubs.param_type(name, metadata) == expected +def test_checkbox_that_sends_a_value_is_not_a_flag(): + assert generate_stubs.param_type("_blrs", {"type": "checkbox", "value_type": "string"}) == "str" + + +def test_request_options_match_the_sdk(): + # Keyword calls only accept the request options listed here, so a new SDK option must be added too. + core = (Path(__file__).resolve().parents[2] / "serpapi" / "core.py").read_text(encoding="utf-8") + sdk_options = {frozenset(re.findall(r'"(\w+)"', keys)) for keys in re.findall(r"for key in \[(.*?)\]", core)} + assert sdk_options == {generate_stubs.REQUEST_OPTION_NAMES} + + def test_only_api_mandatory_params_are_required(engines): assert not params(engines["google"])["q"].required assert not params(engines["google_lens"])["url"].required assert params(engines["extract"])["url"].required -def test_only_google_can_omit_engine(tmp_path): - path = tmp_path / "engines.json" - # The playground's `required` flag on `engine` must not decide this. - path.write_text( - json.dumps( - { - "engines": { - "google": {"engine": {"required": True}, "q": {}}, - "bing": {"engine": {}, "q": {}}, - "extract": {"engine": {}, "url": {"required": True}}, - } - } - ) - ) - loaded = {engine.name: engine for engine in generate_stubs.load_engines(path)} - assert not loaded["google"].engine_required - assert loaded["bing"].engine_required +def test_engine_is_required_except_for_google(engines): + assert not engines["google"].engine_required + assert all(engine.engine_required for name, engine in engines.items() if name != "google") def test_keyword_overloads_skip_names_python_cannot_pass(engines): @@ -118,17 +116,31 @@ def test_rendered_stubs_are_valid_and_cover_engine_shapes(snapshot): assert "params: None = None" in core +def fallbacks(core, function): + """The (signature, return type) of each `**kwargs` overload of a Client method, in order.""" + found = [] + for overload in core.split(f" def {function}(")[1:]: + signature, _, rest = overload.partition(") -> ") + if "**kwargs: Any," in signature: + found.append((signature, rest.split(":")[0])) + return found + + def test_only_extract_accepts_read_only_mappings(snapshot): core = generate_stubs.render(snapshot)["core.pyi"] + assert "params: Union[SearchParams, MutableMapping[str, Any]]," in fallbacks(core, "search")[-1][0] + assert "params: Union[SearchArchiveParams, MutableMapping[str, Any]]," in fallbacks(core, "search_archive")[-1][0] + assert "params: Mapping[str, Any]," in fallbacks(core, "extract")[-1][0] + assert "def locations(params: Optional[MutableMapping[str, Any]] = None" in core - def fallback(function): - overloads = core.split(f"def {function}(")[1:] - return next(overload.split(") ->")[0] for overload in overloads if "**kwargs: Any," in overload.split(") ->")[0]) - assert "params: Union[SearchParams, MutableMapping[str, Any]]," in fallback("search") - assert "params: Union[SearchArchiveParams, MutableMapping[str, Any]]," in fallback("search_archive") - assert "params: Mapping[str, Any]," in fallback("extract") - assert "def locations(params: Optional[MutableMapping[str, Any]] = None" in core +@pytest.mark.parametrize("function", ["search", "extract", "search_archive"]) +def test_output_keyword_decides_the_fallback_return_type(snapshot, function): + # Both literal-output overloads must precede the catch-all. + text, json_output, catch_all = fallbacks(generate_stubs.render(snapshot)["core.pyi"], function) + assert 'output: Literal["html", "md"],' in text[0] and text[1] == "str" + assert 'output: Literal["json"],' in json_output[0] and json_output[1] == "SerpResults" + assert "output:" not in catch_all[0] and catch_all[1] == "Union[SerpResults, Any]" def test_google_can_omit_engine(snapshot): diff --git a/stubs/tests/test_packaging.py b/stubs/tests/test_packaging.py index 02d3c1a..2108e56 100644 --- a/stubs/tests/test_packaging.py +++ b/stubs/tests/test_packaging.py @@ -1,7 +1,134 @@ +import os +import re +import subprocess +import textwrap from pathlib import Path +import pytest + STUBS_ROOT = Path(__file__).resolve().parent.parent def test_license_matches_the_sdk_license(): assert (STUBS_ROOT / "LICENSE").read_bytes() == (STUBS_ROOT.parent / "LICENSE").read_bytes() + + +def test_release_compares_every_path_that_starts_it(): + # The stale-run check in stubs-release.yml must cover the same shipped files as the push trigger. + workflow = (STUBS_ROOT.parent / ".github" / "workflows" / "stubs-release.yml").read_text(encoding="utf-8") + trigger = {path.replace("/**", "") for path in re.findall(r'^ +- "(stubs/[^"]+)"$', workflow, re.MULTILINE)} + compared = re.search(r"stub_paths=\(\s*(.*?)\s*\)", workflow, re.DOTALL).group(1).split() + assert trigger and trigger == set(compared) + + +@pytest.fixture +def git_repo(tmp_path): + repo = tmp_path / "repo" + repo.mkdir() + env = { + **os.environ, + "GIT_CONFIG_GLOBAL": os.devnull, + "GIT_CONFIG_NOSYSTEM": "1", + "GIT_AUTHOR_NAME": "github-actions[bot]", + "GIT_COMMITTER_NAME": "github-actions[bot]", + "GIT_AUTHOR_EMAIL": "bot@example.com", + "GIT_COMMITTER_EMAIL": "bot@example.com", + } + + def git(*args): + return subprocess.run( + ["git", *args], cwd=repo, env=env, check=True, capture_output=True, text=True + ).stdout.strip() + + git("init", "--quiet", "--initial-branch=master") + return repo, env, git + + +@pytest.mark.parametrize("maintainer, regenerated", [(True, False), (True, True), (False, False)]) +def test_refresh_preserves_maintainer_prs(tmp_path, git_repo, maintainer, regenerated): + workflow = (STUBS_ROOT.parent / ".github" / "workflows" / "stubs-refresh.yml").read_text(encoding="utf-8") + script = textwrap.dedent(workflow.rsplit(" run: |\n", 1)[1]) + script = script.replace("${{ github.event.repository.default_branch }}", "master") + calls = tmp_path / "gh-calls" + repo, env, git = git_repo + env.update(BRANCH="bot/refresh-serpapi-stubs", GH_CALLS=str(calls)) + (repo / "stubs").mkdir() + stub = repo / "stubs" / "example.pyi" + stub.write_text("original\n", encoding="utf-8") + git("add", "stubs") + git("commit", "--quiet", "-m", "Base") + git("switch", "--quiet", "-c", env["BRANCH"]) + if maintainer: + env["GIT_AUTHOR_NAME"] = env["GIT_COMMITTER_NAME"] = "Maintainer" + stub.write_text("reviewed correction\n", encoding="utf-8") + git("commit", "--quiet", "-am", "Correct stubs") + tip = git("rev-parse", "HEAD") + git("switch", "--quiet", "master") + git("remote", "add", "origin", str(repo)) + if regenerated: + stub.write_text("new generated metadata\n", encoding="utf-8") + + # Stub only GitHub calls; all branch inspection uses a real, local Git repository. + gh = """ +gh() { + printf '%s\\n' "$*" >> "$GH_CALLS" + if [ "$1 $2" = "pr list" ]; then printf '42\\n'; fi +} +""" + result = subprocess.run( + ["bash", "-e", "-c", gh + script], cwd=repo, env=env, capture_output=True, text=True + ) + assert result.returncode == 0, result.stderr + commands = calls.read_text(encoding="utf-8").splitlines() + assert git("rev-parse", env["BRANCH"]) == tip + if maintainer: + assert len(commands) == 1, commands + assert "left unchanged" in result.stdout + else: + assert any(command.startswith("pr close 42 ") and "--delete-branch" in command for command in commands) + + +@pytest.mark.parametrize( + ("changes", "publish"), + [ + ([], True), + ([(None, "unreleased")], True), + ([("future", "unreleased")], True), + ([("corrected", None)], False), + ([("corrected", None), ("future", "unreleased")], False), + ([("corrected", None), ("original", "unreleased")], False), + ], +) +@pytest.mark.parametrize("branch", ["master", "stubs/hotfix-1.2.0"]) +def test_release_only_skips_for_newer_compatible_stubs(tmp_path, git_repo, changes, publish, branch): + workflow = (STUBS_ROOT.parent / ".github" / "workflows" / "stubs-release.yml").read_text(encoding="utf-8") + step = workflow.split(" - id: current\n", 1)[1] + script = textwrap.dedent(step.split(" run: |\n", 1)[1].split("\n - uses:", 1)[0]) + repo, env, git = git_repo + output = tmp_path / "github_output" + env.update(GITHUB_REF_NAME=branch, GITHUB_OUTPUT=str(output)) + if branch != "master": + git("switch", "--quiet", "-c", branch) + (repo / "serpapi").mkdir() + (repo / "stubs" / "serpapi-stubs").mkdir(parents=True) + sdk = repo / "serpapi" / "core.py" + stub = repo / "stubs" / "serpapi-stubs" / "core.pyi" + sdk.write_text("released\n", encoding="utf-8") + stub.write_text("original\n", encoding="utf-8") + git("add", "serpapi", "stubs") + git("commit", "--quiet", "-m", "Released SDK with stub fix") + running_commit = git("rev-parse", "HEAD") + for new_stub, new_sdk in changes: + if new_stub is not None: + stub.write_text(new_stub + "\n", encoding="utf-8") + if new_sdk is not None: + sdk.write_text(new_sdk + "\n", encoding="utf-8") + git("commit", "--quiet", "-am", "Next change") + git("remote", "add", "origin", str(repo)) + git("switch", "--quiet", "--detach", running_commit) + + result = subprocess.run( + ["bash", "-e", "-c", script], cwd=repo, env=env, capture_output=True, text=True + ) + assert result.returncode == 0, result.stderr + assert output.read_text(encoding="utf-8") == f"publish={str(publish).lower()}\n" diff --git a/stubs/tests/test_release_version.py b/stubs/tests/test_release_version.py index 79bc71b..3a29e6f 100644 --- a/stubs/tests/test_release_version.py +++ b/stubs/tests/test_release_version.py @@ -107,12 +107,47 @@ def test_series_check(tmp_path, monkeypatch, tag, existing, exit_code, github_ou output.touch() monkeypatch.setenv("GITHUB_OUTPUT", str(output)) monkeypatch.setattr(release_version, "read_sdk_version", lambda: "1.2.0") - monkeypatch.setattr(release_version, "published_versions", lambda: existing) + monkeypatch.setattr( + release_version, "urlopen", respond_with({"releases": {version: [{"yanked": False}] for version in existing}}) + ) assert release_version.main(["--series-check", tag]) == exit_code assert output.read_text() == github_output +@pytest.mark.parametrize( + ("files", "publish"), + [ + ([], True), + ([{"yanked": True}], True), + ([{"yanked": False}], False), + ([{"yanked": True}, {"yanked": False}], False), + ([{}], False), + ], +) +def test_series_requires_available_files_but_reserves_every_version(tmp_path, monkeypatch, files, publish): + version = "1.2.0.20260102" + output = tmp_path / "github_output" + monkeypatch.setenv("GITHUB_OUTPUT", str(output)) + monkeypatch.setattr( + release_version, "urlopen", + respond_with({"releases": {version: files, "1.1.0.20260102": [{"yanked": False}]}}), + ) + + assert release_version.series_check("v1.2.0", "1.2.0") == 0 + assert output.read_text() == f"publish={str(publish).lower()}\n" + assert release_version.next_version("1.2.0", DAY, release_version.published_versions()) == version + ".1" + + def test_sdk_version_flag_prints_the_sdk_version(capsys): assert release_version.main(["--sdk-version"]) == 0 assert capsys.readouterr().out == release_version.read_sdk_version() + "\n" + + +def test_non_final_sdk_version_fails_with_a_message(monkeypatch, capsys): + def non_final(): + raise ValueError("SDK version '1.3.0rc1' is not a final X.Y.Z release") + + monkeypatch.setattr(release_version, "read_sdk_version", non_final) + assert release_version.main(["--series-check", "v1.3.0rc1"]) == 1 + assert "not a final X.Y.Z release" in capsys.readouterr().err diff --git a/stubs/tests/typecheck/check_errors.py b/stubs/tests/typecheck/check_errors.py index a9d8d7a..31abae5 100644 --- a/stubs/tests/typecheck/check_errors.py +++ b/stubs/tests/typecheck/check_errors.py @@ -14,6 +14,8 @@ client.search(engine="gogle", q="coffee") # type: ignore client.search(search_query="coffee") # type: ignore client.search(engine="google", q="coffee", device="watch") # type: ignore +# A Python bool is sent as "False", which SerpApi ignores here; the parameter takes "true" or "false". +client.search(engine="yandex", text="coffee", fix_typo=False) # type: ignore client.search(engine="google", q="coffee", output="xml") # type: ignore client.search(engine="google", q="coffee", timeout="30") # type: ignore serpapi.extract() # type: ignore @@ -25,7 +27,7 @@ client.search(MappingProxyType({"engine": "google", "q": "coffee"})) # type: ignore client.search_archive(MappingProxyType({"search_id": "abc"})) # type: ignore -# Untyped dict literals fall back to Mapping[str, Any]; annotate them with a TypedDict for key checking. +# Untyped dict literals match the fallback overload unchecked; annotate them with a TypedDict for key checking. typo: "GoogleJsonSearchParams" = {"engine": "google", "qq": "coffee"} # type: ignore bad_output: "GoogleJsonSearchParams" = {"engine": "google", "q": "coffee", "output": "md"} # type: ignore no_url: "ExtractJsonParams" = {"timeout": 30000} # type: ignore diff --git a/stubs/tests/typecheck/check_usage.py b/stubs/tests/typecheck/check_usage.py index 69fe91d..03238c3 100644 --- a/stubs/tests/typecheck/check_usage.py +++ b/stubs/tests/typecheck/check_usage.py @@ -9,7 +9,14 @@ from serpapi import Client, SerpResults if TYPE_CHECKING: - from serpapi.engine_params import GoogleJsonSearchParams, SearchArchiveParams, SearchParams + from serpapi.engine_params import ( + ExtractTextParams, + GoogleJsonSearchParams, + GoogleTextSearchParams, + SearchArchiveParams, + SearchArchiveTextParams, + SearchParams, + ) client = Client(api_key="secret", timeout=20) @@ -23,16 +30,18 @@ assert_type(client.search(engine="google_lens", image_id="abc", hl="en"), SerpResults) assert_type(client.search(engine="google", q="coffee", timeout=(3.0, 30.0), verify=False), SerpResults) assert_type(client.search(engine="google", q="coffee", proxies=None, cert=None, verify=None, stream=None), SerpResults) +assert_type(client.search(engine="google", q="coffee", proxies={"https": None}), SerpResults) +assert_type(client.search(engine="ebay", _nkw="coffee", _blrs="spell_auto_correct"), SerpResults) assert_type(client.search(engine="google_maps", q="coffee", min_rating=4.5), SerpResults) assert_type(client.search(engine="doordash", q="coffee", min_rating=4.5), SerpResults) assert_type(client.search(engine="amazon", k="coffee", language="en_US"), SerpResults) assert_type(client.search(engine="naver", query="coffee", page=2, start=21), SerpResults) +assert_type(client.search(engine="yandex", text="coffee", sort_mode="date"), SerpResults) assert_type(client.search({"engine": "google", "q": "coffee", "async": True}), SerpResults) client.search({"engine": "google_images", "tbm": "isch", "q": "coffee"}) client.search({"engine": "google_play", "q": "kite", "store": "apps", "max_results": "2"}) assert_type(client.search({"engine": "google", "q": "coffee", "output": "md"}), str) assert_type(client.search({"engine": "google_translate", "text": "hi", "from": "en"}), SerpResults) -assert_type(client.search({"engine": "google", "q": "coffee", "async": True}), SerpResults) assert_type(serpapi.search(engine="google", q="coffee", output="md"), str) def runtime_engine(name: str) -> None: @@ -41,6 +50,21 @@ def runtime_engine(name: str) -> None: params: Dict[str, Any] = {"engine": "google", "q": "coffee"} assert_type(client.search(params), Union[SerpResults, Any]) assert_type(client.search(params, start=10), Union[SerpResults, Any]) +# An `output` keyword overrides the mapping, so the result type is known even for an untyped dict. +assert_type(client.search(params, output="md"), str) +assert_type(client.extract({"url": "https://example.com"}, output="html"), str) +assert_type(client.search(params, output="json"), SerpResults) +assert_type(client.extract(params, output="json"), SerpResults) +assert_type(client.search_archive(params, output="json"), SerpResults) + + +def json_overrides_text( + search: "GoogleTextSearchParams", extract: "ExtractTextParams", archive: "SearchArchiveTextParams" +) -> None: + assert_type(client.search(search, output="json"), SerpResults) + assert_type(client.extract(extract, output="json"), SerpResults) + assert_type(client.search_archive(archive, output="json"), SerpResults) + assert_type(serpapi.search(search, output="json"), SerpResults) typed: "GoogleJsonSearchParams" = {"engine": "google", "q": "coffee", "device": "mobile"} assert_type(client.search(typed), SerpResults) diff --git a/stubs/tools/fetch_engines.py b/stubs/tools/fetch_engines.py index 268358b..51d2791 100644 --- a/stubs/tools/fetch_engines.py +++ b/stubs/tools/fetch_engines.py @@ -25,6 +25,10 @@ # Playground parameter types whose options are the complete list of accepted values. CLOSED_CHOICE_TYPES = frozenset({"select", "dropdown", "device"}) DOCUMENTED_VALUE = re.compile(r"(.*?)", re.DOTALL) +# A value in a documented list of choices: `value - label`. +LISTED_VALUE = re.compile(r"([\w.\-]+)\s+[-–—]\s") +# Checkboxes that send a value instead of a flag: eBay's `_blrs` takes `spell_auto_correct`. +VALUE_CHECKBOXES = frozenset({("ebay", "_blrs")}) TIMEOUT_SECONDS = 60 USER_AGENT = "serpapi-stubs-refresh (+https://github.com/serpapi/serpapi-python)" @@ -73,17 +77,22 @@ def _is_closed_choice(metadata: dict[str, Any], values: list[str]) -> bool: """Whether the options are the only accepted values, so a Literal type does not reject valid calls.""" if metadata.get("type") not in CLOSED_CHOICE_TYPES: return False - # Some options are documented in another case than the option list (e.g. Bing's `mkt`, `cc`), which - # means the API does not match case-sensitively. description = metadata.get("html") - documented = DOCUMENTED_VALUE.findall(description) if isinstance(description, str) else [] + if not isinstance(description, str): + return True + # Decode entities first, so that `—` separators and escaped values compare as displayed. + description = html.unescape(description) accepted = set(values) folded = {value.casefold() for value in values} - for token in documented: - value = html.unescape(token).strip() + # Some options are documented in another case than the option list (e.g. Bing's `mkt`, `cc`), which + # means the API does not match case-sensitively. + for token in DOCUMENTED_VALUE.findall(description): + value = token.strip() if value not in accepted and value.casefold() in folded: return False - return True + # A listed value that the options lack means the option list is wrong or incomplete (Yandex's + # `sort_mode` offers `time` where the API takes `date`). + return all(value.casefold() in folded for value in LISTED_VALUE.findall(description)) def normalize_param(name: str, metadata: Any, engine: str | None = None) -> dict[str, Any]: @@ -93,8 +102,8 @@ def normalize_param(name: str, metadata: Any, engine: str | None = None) -> dict param_type = metadata.get("type") if isinstance(param_type, str) and param_type: param["type"] = param_type - if metadata.get("required") is True: - param["required"] = True + if (engine, name) in VALUE_CHECKBOXES: + param["value_type"] = "string" options = metadata.get("options") if isinstance(options, list) and options: values = [] diff --git a/stubs/tools/generate_stubs.py b/stubs/tools/generate_stubs.py index 4d1a9e4..a586ab8 100644 --- a/stubs/tools/generate_stubs.py +++ b/stubs/tools/generate_stubs.py @@ -29,7 +29,7 @@ BOOLEAN_PARAM_NAMES = frozenset({"async", "include_filters", "no_cache", "zero_trace"}) RESERVED_KEYWORD_NAMES = frozenset({"params", "self"}) # Playground "required" flags are often conditional (for example, google_lens `url` can be replaced by -# `image_id`), so only parameters the API cannot work without are required. +# `image_id`), so the snapshot does not keep them; only parameters the API cannot work without are required. REQUIRED_PARAMS = {"extract": frozenset({"url"})} # SerpApi runs Google when `engine` is omitted, so only Google calls may leave it out. DEFAULT_ENGINE = "google" @@ -89,7 +89,8 @@ def literal(values: list[Any]) -> str: def param_type(name: str, metadata: dict[str, Any]) -> str: - if name == "api_key": + # `value_type` is the fetcher's verdict, and it overrides the playground's widget type. + if name == "api_key" or metadata.get("value_type") == "string": return "str" if name in BOOLEAN_PARAM_NAMES or metadata.get("type") == "checkbox": return "_Flag" @@ -237,7 +238,12 @@ def mapping_overloads(function: str, receiver: str | None, json_type: str, text_ def fallback_overload(function: str, receiver: str | None, params_type: str) -> list[str]: - return overload(function, receiver, [f"params: {params_type}", "**kwargs: Any"], FALLBACK_RETURN) + params = f"params: {params_type}" + # An `output` keyword overrides the mapping, so a literal value determines the result type. + lines = overload(function, receiver, [params, "*", f"output: {TEXT_OUTPUT}", "**kwargs: Any"], "str") + lines.extend(overload(function, receiver, [params, "*", f"output: {JSON_OUTPUT}", "**kwargs: Any"], "SerpResults")) + lines.extend(overload(function, receiver, [params, "**kwargs: Any"], FALLBACK_RETURN)) + return lines def search_overloads(engines: list[Engine], receiver: str | None) -> list[str]: @@ -337,7 +343,9 @@ def write(outputs: dict[str, str], output_dir: Path = OUTPUT_DIR) -> list[Path]: if path.exists() and path.read_text(encoding="utf-8") == outputs[name]: continue path.parent.mkdir(parents=True, exist_ok=True) - path.write_text(outputs[name], encoding="utf-8", newline="\n") + # Path.write_text() only accepts `newline` from Python 3.10. + with open(path, "w", encoding="utf-8", newline="\n") as handle: + handle.write(outputs[name]) written.append(path) return written diff --git a/stubs/tools/release_version.py b/stubs/tools/release_version.py index bf9d7d0..8579afa 100644 --- a/stubs/tools/release_version.py +++ b/stubs/tools/release_version.py @@ -50,7 +50,7 @@ def has_published_series(sdk_version: str, existing: Iterable[str]) -> bool: return any(version.startswith(prefix) for version in existing) -def published_versions(url: str = PYPI_JSON_URL) -> set[str]: +def published_versions(url: str = PYPI_JSON_URL, *, available_only: bool = False) -> set[str]: request = Request(url, headers={"Accept": "application/json"}) try: with urlopen(request, timeout=30) as response: @@ -59,21 +59,26 @@ def published_versions(url: str = PYPI_JSON_URL) -> set[str]: if error.code == 404: return set() raise - return set(payload["releases"]) + releases = payload["releases"] + if available_only: + return { + version for version, files in releases.items() + if any(not file.get("yanked", False) for file in files) + } + return set(releases) def parse_date(value: str) -> datetime.date: return datetime.datetime.strptime(value, "%Y%m%d").date() -def series_check(tag: str) -> int: +def series_check(tag: str, sdk_version: str) -> int: """For an SDK release tag: verify it names the SDK version and report whether its stubs still need publishing.""" - sdk_version = read_sdk_version() if tag != f"v{sdk_version}": print(f"Release tag {tag!r} does not match SDK version tag 'v{sdk_version}'", file=sys.stderr) return 1 - # A stub-only release may already have published this series; an SDK tag must not supersede it. - publish = not has_published_series(sdk_version, published_versions()) + # Preserve an installable series, but allow recovery when all its files were yanked or deleted. + publish = not has_published_series(sdk_version, published_versions(available_only=True)) print(f"{'Publishing' if publish else 'Skipping'} stubs for SDK {sdk_version}") github_output = os.environ.get("GITHUB_OUTPUT") if github_output: @@ -98,14 +103,19 @@ def parse_args(argv: list[str]) -> argparse.Namespace: def main(argv: list[str] | None = None) -> int: args = parse_args(sys.argv[1:] if argv is None else argv) + try: + sdk_version = read_sdk_version() + except ValueError as error: + print(error, file=sys.stderr) + return 1 if args.sdk_version: - print(read_sdk_version()) + print(sdk_version) return 0 if args.series_check is not None: - return series_check(args.series_check) + return series_check(args.series_check, sdk_version) date = args.date or datetime.datetime.now(datetime.timezone.utc).date() existing = set() if args.offline else published_versions() - version = next_version(read_sdk_version(), date, existing) + version = next_version(sdk_version, date, existing) args.output.write_text(version + "\n", encoding="utf-8") print(version) return 0 From 3583e960eb247d07eb5da275c2b056fe5dd2570f Mon Sep 17 00:00:00 2001 From: Adarsh Divakaran Date: Wed, 18 Nov 2026 14:13:08 +0530 Subject: [PATCH 4/4] fix: tighten stub release guards and proxy typing Skip an older stub release only when a newer compatible stub snapshot has its own release run, so a multi-commit push no longer drops or duplicates a release. Keep a refresh branch that has a maintainer commit anywhere in its history. Require a mutable mapping for proxies, which requests updates in place. Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com> --- .github/workflows/stubs-refresh.yml | 6 ++- .github/workflows/stubs-release.yml | 24 +++++++--- CONTRIBUTING.md | 4 +- stubs/README.md | 5 ++- stubs/serpapi-stubs/http.pyi | 8 ++-- stubs/tests/test_packaging.py | 65 ++++++++++++++++++++++----- stubs/tests/typecheck/check_errors.py | 1 + stubs/tests/typecheck/check_usage.py | 4 ++ 8 files changed, 92 insertions(+), 25 deletions(-) diff --git a/.github/workflows/stubs-refresh.yml b/.github/workflows/stubs-refresh.yml index 4b71da9..9e178c3 100644 --- a/.github/workflows/stubs-refresh.yml +++ b/.github/workflows/stubs-refresh.yml @@ -29,6 +29,7 @@ jobs: with: ref: ${{ github.event.repository.default_branch }} token: ${{ secrets.STUBS_REFRESH_TOKEN || github.token }} + fetch-depth: 0 - uses: actions/setup-python@v6 with: @@ -55,9 +56,10 @@ jobs: branch_tip="" human_commits=false if [ -n "$open_pr" ]; then - git fetch --quiet --depth=1 origin "$BRANCH" + git fetch --quiet origin "$BRANCH" branch_tip=$(git rev-parse FETCH_HEAD) - if [ "$(git log -1 --format='%an/%cn' "$branch_tip")" != "$bot/$bot" ]; then + commit_authors=$(git log --format='%an/%cn' "HEAD..$branch_tip") + if [ -n "$commit_authors" ] && grep -qFxv "$bot/$bot" <<< "$commit_authors"; then human_commits=true fi fi diff --git a/.github/workflows/stubs-release.yml b/.github/workflows/stubs-release.yml index 669d313..7c0bc8b 100644 --- a/.github/workflows/stubs-release.yml +++ b/.github/workflows/stubs-release.yml @@ -79,6 +79,7 @@ jobs: name: pypi-stubs url: https://pypi.org/p/serpapi-stubs permissions: + actions: read contents: read id-token: write steps: @@ -90,6 +91,8 @@ jobs: # publishing job because "Re-run failed jobs" keeps the outputs of the jobs that already passed. - id: current name: Do not supersede newer stubs for the same SDK + env: + GH_TOKEN: ${{ github.token }} run: | git fetch --quiet origin "refs/heads/$GITHUB_REF_NAME" if ! git merge-base --is-ancestor HEAD FETCH_HEAD; then @@ -98,17 +101,26 @@ jobs: exit 0 fi - # Only a newer shipped-stub change for this SDK can replace this release. Look through history, + # Only a newer shipped-stub snapshot for this SDK can replace this release. Look through history, # because the branch tip may already target an unreleased SDK. Keep these paths with on.push.paths. stub_paths=( stubs/serpapi-stubs stubs/pyproject.toml stubs/MANIFEST.in stubs/LICENSE stubs/README.md ) - commits=$(git rev-list --first-parent HEAD..FETCH_HEAD -- "${stub_paths[@]}") + commits=$(git rev-list --first-parent HEAD..FETCH_HEAD) for commit in $commits; do - if git diff --quiet HEAD "$commit" -- serpapi/; then - echo "::notice::Newer compatible stub change $commit supersedes this run; use that commit's run to release." - echo "publish=false" >> "$GITHUB_OUTPUT" - exit 0 + if git diff --quiet HEAD "$commit" -- serpapi/ && + ! git diff --quiet HEAD "$commit" -- "${stub_paths[@]}"; then + # A push head can carry earlier stub changes without itself changing a shipped file. + replacement_run=$(gh api --method GET \ + "repos/$GITHUB_REPOSITORY/actions/workflows/stubs-release.yml/runs" \ + -f head_sha="$commit" -f branch="$GITHUB_REF_NAME" -f per_page=1 \ + --jq '.workflow_runs[0].html_url // empty') + if [ -n "$replacement_run" ]; then + echo "::notice::Newer compatible stub snapshot $commit supersedes this run; use $replacement_run to release." + echo "publish=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + echo "::notice::Newer compatible stub snapshot $commit has no release run; it does not supersede this run." fi done echo "publish=true" >> "$GITHUB_OUTPUT" diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 44c0a5b..ee338e3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -174,7 +174,7 @@ See the [RTD build API](https://docs.readthedocs.com/platform/stable/api/v3.html The `stubs/` directory builds `serpapi-stubs`, a separate PyPI distribution that users install with `pip install "serpapi[typing]"`. The SDK wheel and source distribution do not include it. See [stubs/README.md](stubs/README.md) for the layout and the commands that refresh and regenerate the stubs. -The [stubs workflow](.github/workflows/stubs.yml) runs on pull requests that change `serpapi/` or `stubs/`. To run the same checks locally, install the stubs into your development environment and type-check the samples: +The [stubs workflow](.github/workflows/stubs.yml) runs on pull requests that change `serpapi/` or `stubs/`. To run the same checks locally, use Python 3.13 as in CI, install the stubs into your development environment, and type-check the samples: ```sh cd stubs @@ -205,7 +205,7 @@ GitHub can refuse a push that carries workflow-file changes from `master` into a If a stub release breaks valid code, yank it on PyPI and merge a fix. The SDK-tag workflow does not supersede a series with any non-yanked files. If the series has only yanked releases or no files left, it publishes a replacement before the SDK. Yanked and file-less versions still reserve their version numbers. For an upload collision between simultaneous stub releases, choose **Re-run all jobs** on the latest compatible run of the stub-only release workflow. It computes the next available date suffix, whereas **Re-run failed jobs** reuses the colliding version. -The stub-only workflow queues up to 100 pending runs across release branches, rather than letting a hotfix or manual dispatch replace an already pending release. Before uploading, it checks the branch's first-parent history: a newer shipped-stub change for the same SDK supersedes an older run, but a change targeting an unreleased SDK does not suppress the last compatible release. A run whose commit was removed from the branch is also skipped. After a cancellation or a full queue, rerun all jobs on the newest compatible run, not an older superseded one. +The stub-only workflow queues up to 100 pending runs across release branches, rather than letting a hotfix or manual dispatch replace an already pending release. Before uploading, it checks every commit in the branch's first-parent history: a newer commit with different shipped stubs for the same SDK supersedes an older run only when that commit has a run of this workflow on the same branch. The head of a multi-commit push can carry an earlier stub fix even if its own change is documentation-only. An intermediate commit with no release run does not suppress the pending release, nor does a change targeting an unreleased SDK. Run-lookup errors fail the publishing job rather than assuming a replacement exists. A run whose commit was removed from the branch is also skipped. After a cancellation or a full queue, rerun all jobs on the newest compatible run, not an older superseded one. Release tags publish only the files in the tagged commit. If a stub change was skipped while waiting for a tag but landed after that commit, manually run **Release serpapi-stubs** on `master` once the tag exists, provided `serpapi/` still matches it. If SDK development has moved on, use the hotfix procedure below instead. diff --git a/stubs/README.md b/stubs/README.md index b226e77..4b1d8bc 100644 --- a/stubs/README.md +++ b/stubs/README.md @@ -54,6 +54,7 @@ Notes: - `async` and `from` are Python keywords, so pass them in the params dict: `client.search({"engine": "google", "q": "coffee", "async": True})`. - In keyword calls, `timeout` is the HTTP request timeout. Pass Extract's API `timeout` parameter in the params dict. +- `proxies` accepts a mutable mapping such as `dict`, not a read-only `Mapping`: Requests updates it when merging environment proxies. A `None` value disables that configured proxy. - Keyword calls need literal `engine` and `output` values so the checker can select the engine's overload. A `str` variable, or `**` unpacking of a `Dict[str, str]`, is rejected. When either value is computed at runtime, pass a params dict, or type the value as `Literal` or `Final`. - A `dict` variable that is not annotated with a parameter type gives a `SerpResults | Any` result, because the checker cannot see its `output` value. Pass `output="md"` or `output="html"` as a keyword to get `str`, or `output="json"` to get `SerpResults`. The keyword overrides any `output` in the mapping. - `search()`, `search_archive()`, `locations()`, and `account()` write the API key into the mapping they receive, so pass a `dict` or a `serpapi.engine_params` type. A read-only `Mapping` or your own `TypedDict` is rejected; pass `dict(params)` instead. `extract()` copies its mapping and accepts any `Mapping`. @@ -61,7 +62,7 @@ Notes: Engine parameters come from the [SerpApi Playground](https://serpapi.com/playground). Parameters that SerpApi has not documented there are reported as errors. Use a `# type: ignore` comment or an untyped `dict` if you need one. Parameters that the Playground gives no type accept `str`, `int`, or `float`, because the SDK sends numbers as text. -The Playground sometimes uses UI-specific values rather than the API values (for example, Amazon language choices combine a domain and locale). The stubs normalize those choices to the API's documented locale codes. A parameter is typed as a closed set of options only when the Playground presents it as a single-choice list that agrees with its documentation. Parameters that document case-insensitive values (such as Bing's `mkt`, `cc`, and `safeSearch`), comma-separated values (such as Tripadvisor Reviews' `type_of_visit`), or a value missing from the list (such as Yandex's `sort_mode`) are typed `str`. When an engine parameter is not present in the Playground, pass a mapping to `search()`; mapping calls remain compatible with runtime-supported parameters without weakening keyword checks. +The Playground sometimes uses UI-specific values rather than the API values (for example, Amazon language choices combine a domain and locale). The stubs normalize those choices to the API's documented locale codes. A parameter is typed as a closed set of options only when the Playground presents it as a single-choice list that agrees with its documentation. Parameters that document case-insensitive values (such as `mkt`, `cc`, and `safeSearch` for `bing` and `bing_news`), comma-separated values (such as Tripadvisor Reviews' `type_of_visit`), or a value missing from the list (such as Yandex's `sort_mode`) are typed `str`. These checks apply per engine: `bing_images` documents only lowercase `safeSearch` choices, so its type remains `Literal["strict", "moderate", "off"]`. When an engine parameter is not present in the Playground, pass a mapping to `search()`; mapping calls remain compatible with runtime-supported parameters without weakening keyword checks. ## Versions @@ -81,6 +82,8 @@ A stub release that breaks valid code is yanked from PyPI and fixed in a newer r ## Development +Building this distribution from source requires Python 3.9 or newer for `setuptools>=77`. Installing a published wheel does not require the build backend. Use Python 3.13 for development checks, matching CI. + The stubs are built from the [`stubs/`](https://github.com/serpapi/serpapi-python/tree/master/stubs) directory of the SDK repository: - `data/engines.json`: engine metadata collected from the SerpApi Playground. diff --git a/stubs/serpapi-stubs/http.pyi b/stubs/serpapi-stubs/http.pyi index 2f3f4a2..69c8700 100644 --- a/stubs/serpapi-stubs/http.pyi +++ b/stubs/serpapi-stubs/http.pyi @@ -1,11 +1,13 @@ -from typing import Any, Mapping, MutableMapping, Optional, Tuple, Union +from typing import Any, MutableMapping, Optional, Tuple, Union import requests from typing_extensions import TypeAlias _Timeout: TypeAlias = Union[None, float, Tuple[Optional[float], Optional[float]]] -# requests removes a proxy whose value is None, which is how one request opts out of a configured proxy. -_Proxies: TypeAlias = Union[None, Mapping[str, Optional[str]]] +# requests mutates proxies when merging the environment; None opts out of a configured proxy. +_Proxies: TypeAlias = Union[ + None, MutableMapping[str, str], MutableMapping[str, None], MutableMapping[str, Optional[str]] +] _Verify: TypeAlias = Union[None, bool, str] _Cert: TypeAlias = Union[None, str, Tuple[str, str]] diff --git a/stubs/tests/test_packaging.py b/stubs/tests/test_packaging.py index 2108e56..b852c06 100644 --- a/stubs/tests/test_packaging.py +++ b/stubs/tests/test_packaging.py @@ -45,7 +45,8 @@ def git(*args): @pytest.mark.parametrize("maintainer, regenerated", [(True, False), (True, True), (False, False)]) -def test_refresh_preserves_maintainer_prs(tmp_path, git_repo, maintainer, regenerated): +@pytest.mark.parametrize("bot_followup", [False, True]) +def test_refresh_preserves_maintainer_prs(tmp_path, git_repo, maintainer, regenerated, bot_followup): workflow = (STUBS_ROOT.parent / ".github" / "workflows" / "stubs-refresh.yml").read_text(encoding="utf-8") script = textwrap.dedent(workflow.rsplit(" run: |\n", 1)[1]) script = script.replace("${{ github.event.repository.default_branch }}", "master") @@ -62,6 +63,10 @@ def test_refresh_preserves_maintainer_prs(tmp_path, git_repo, maintainer, regene env["GIT_AUTHOR_NAME"] = env["GIT_COMMITTER_NAME"] = "Maintainer" stub.write_text("reviewed correction\n", encoding="utf-8") git("commit", "--quiet", "-am", "Correct stubs") + if bot_followup: + env["GIT_AUTHOR_NAME"] = env["GIT_COMMITTER_NAME"] = "github-actions[bot]" + stub.write_text("reviewed correction\nbot followup\n", encoding="utf-8") + git("commit", "--quiet", "-am", "Bot followup") tip = git("rev-parse", "HEAD") git("switch", "--quiet", "master") git("remote", "add", "origin", str(repo)) @@ -89,24 +94,33 @@ def test_refresh_preserves_maintainer_prs(tmp_path, git_repo, maintainer, regene @pytest.mark.parametrize( - ("changes", "publish"), + ("changes", "run_lookup", "publish"), [ - ([], True), - ([(None, "unreleased")], True), - ([("future", "unreleased")], True), - ([("corrected", None)], False), - ([("corrected", None), ("future", "unreleased")], False), - ([("corrected", None), ("original", "unreleased")], False), + ([], "missing", True), + ([(None, "unreleased")], "missing", True), + ([("future", "unreleased")], "missing", True), + ([("corrected", None)], "found", False), + ([("corrected", None), ("future", "unreleased")], "found", False), + ([("corrected", None), ("original", "unreleased")], "found", False), + ([("corrected", None)], "missing", True), + ([("corrected", None), ("future", "unreleased")], "missing", True), + ([("corrected", None)], "error", None), + ([("corrected", None), (None, None)], "tip", False), + ([(None, None)], "tip", True), ], ) @pytest.mark.parametrize("branch", ["master", "stubs/hotfix-1.2.0"]) -def test_release_only_skips_for_newer_compatible_stubs(tmp_path, git_repo, changes, publish, branch): +def test_release_only_skips_for_newer_compatible_stubs(tmp_path, git_repo, changes, run_lookup, publish, branch): workflow = (STUBS_ROOT.parent / ".github" / "workflows" / "stubs-release.yml").read_text(encoding="utf-8") step = workflow.split(" - id: current\n", 1)[1] script = textwrap.dedent(step.split(" run: |\n", 1)[1].split("\n - uses:", 1)[0]) repo, env, git = git_repo output = tmp_path / "github_output" - env.update(GITHUB_REF_NAME=branch, GITHUB_OUTPUT=str(output)) + calls = tmp_path / "gh-calls" + env.update( + GITHUB_REF_NAME=branch, GITHUB_OUTPUT=str(output), GITHUB_REPOSITORY="example/repo", + RELEASE_RUN=run_lookup, GH_CALLS=str(calls), + ) if branch != "master": git("switch", "--quiet", "-c", branch) (repo / "serpapi").mkdir() @@ -123,12 +137,41 @@ def test_release_only_skips_for_newer_compatible_stubs(tmp_path, git_repo, chang stub.write_text(new_stub + "\n", encoding="utf-8") if new_sdk is not None: sdk.write_text(new_sdk + "\n", encoding="utf-8") + if new_stub is None and new_sdk is None: + (repo / "CONTRIBUTING.md").write_text("Documentation follow-up\n", encoding="utf-8") + git("add", "CONTRIBUTING.md") git("commit", "--quiet", "-am", "Next change") + env["RUN_HEAD"] = git("rev-parse", "HEAD") git("remote", "add", "origin", str(repo)) git("switch", "--quiet", "--detach", running_commit) + gh = """ +gh() { + printf '%s\\n' "$*" >> "$GH_CALLS" + case "$RELEASE_RUN" in + found) printf 'https://github.com/example/repo/actions/runs/42\\n' ;; + tip) + for arg in "$@"; do + if [ "$arg" = "head_sha=$RUN_HEAD" ]; then + printf 'https://github.com/example/repo/actions/runs/42\\n' + fi + done + ;; + error) printf 'run lookup failed\\n' >&2; return 1 ;; + esac +} +""" result = subprocess.run( - ["bash", "-e", "-c", script], cwd=repo, env=env, capture_output=True, text=True + ["bash", "-e", "-c", gh + script], cwd=repo, env=env, capture_output=True, text=True ) + if run_lookup == "error": + assert result.returncode != 0 + assert "run lookup failed" in result.stderr + assert not output.exists() + return assert result.returncode == 0, result.stderr assert output.read_text(encoding="utf-8") == f"publish={str(publish).lower()}\n" + if not publish: + assert "https://github.com/example/repo/actions/runs/42" in result.stdout + if calls.exists(): + assert f"branch={branch}" in calls.read_text(encoding="utf-8") diff --git a/stubs/tests/typecheck/check_errors.py b/stubs/tests/typecheck/check_errors.py index 31abae5..67c6b96 100644 --- a/stubs/tests/typecheck/check_errors.py +++ b/stubs/tests/typecheck/check_errors.py @@ -18,6 +18,7 @@ client.search(engine="yandex", text="coffee", fix_typo=False) # type: ignore client.search(engine="google", q="coffee", output="xml") # type: ignore client.search(engine="google", q="coffee", timeout="30") # type: ignore +client.search(engine="google", q="coffee", proxies=MappingProxyType({"https": "http://proxy:8080"})) # type: ignore serpapi.extract() # type: ignore client.search_archive() # type: ignore serpapi.Client("secret") # type: ignore diff --git a/stubs/tests/typecheck/check_usage.py b/stubs/tests/typecheck/check_usage.py index 03238c3..946d21e 100644 --- a/stubs/tests/typecheck/check_usage.py +++ b/stubs/tests/typecheck/check_usage.py @@ -31,6 +31,10 @@ assert_type(client.search(engine="google", q="coffee", timeout=(3.0, 30.0), verify=False), SerpResults) assert_type(client.search(engine="google", q="coffee", proxies=None, cert=None, verify=None, stream=None), SerpResults) assert_type(client.search(engine="google", q="coffee", proxies={"https": None}), SerpResults) +proxy_urls: Dict[str, str] = {"https": "http://proxy:8080"} +optional_proxy_urls: Dict[str, Union[str, None]] = {"https": None} +assert_type(client.search(engine="google", q="coffee", proxies=proxy_urls), SerpResults) +assert_type(client.search(engine="google", q="coffee", proxies=optional_proxy_urls), SerpResults) assert_type(client.search(engine="ebay", _nkw="coffee", _blrs="spell_auto_correct"), SerpResults) assert_type(client.search(engine="google_maps", q="coffee", min_rating=4.5), SerpResults) assert_type(client.search(engine="doordash", q="coffee", min_rating=4.5), SerpResults)