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 7e37094..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" @@ -71,9 +72,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 +191,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 +203,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 +220,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__}.*"']