From bd3f178457f7cc006367e0d1bebf8ef8a9feb51d Mon Sep 17 00:00:00 2001 From: Gallay David Date: Mon, 9 Sep 2024 20:41:30 +0200 Subject: [PATCH] first commit --- .github/dependabot.yml | 11 + .github/workflows/docs.yml | 51 + .github/workflows/gitleaks.yml | 19 + .github/workflows/pre-commit.yml | 45 + .github/workflows/python-publish.yml | 37 + .gitignore | 175 + .pre-commit-config.yaml | 114 + .python-ci.yml | 34 + .python-version | 1 + .readthedocs.yaml | 19 + .semgrepignore | 1 + LICENSE | 201 + Makefile | 11 + PaloAlto_API_Insight.md | 67 + README.md | 55 + examples/__init__.py | 0 mypy.ini | 17 + pa_api/__init__.py | 10 + pa_api/__main__.py | 11 + pa_api/constants.py | 41 + pa_api/panorama.py | 33 + pa_api/restapi/__init__.py | 8 + pa_api/restapi/rest_resources.py | 419 ++ pa_api/restapi/restapi.py | 306 ++ pa_api/utils.py | 47 + pa_api/xmlapi/__init__.py | 7 + pa_api/xmlapi/base.py | 137 + pa_api/xmlapi/client.py | 1124 ++++++ pa_api/xmlapi/constants.py | 3 + pa_api/xmlapi/objects.py | 35 + pa_api/xmlapi/types/__init__.py | 28 + pa_api/xmlapi/types/config/__init__.py | 15 + pa_api/xmlapi/types/config/address.py | 92 + pa_api/xmlapi/types/config/devicegroup.py | 46 + pa_api/xmlapi/types/config/interface.py | 373 ++ .../xmlapi/types/config/routing/__init__.py | 2 + .../types/config/routing/routing_table.py | 34 + pa_api/xmlapi/types/config/rules/__init__.py | 4 + pa_api/xmlapi/types/config/rules/nat.py | 135 + pa_api/xmlapi/types/config/rules/rulebase.py | 19 + pa_api/xmlapi/types/config/rules/security.py | 82 + pa_api/xmlapi/types/config/zone.py | 33 + pa_api/xmlapi/types/operations/__init__.py | 4 + pa_api/xmlapi/types/operations/device.py | 174 + pa_api/xmlapi/types/operations/job.py | 88 + pa_api/xmlapi/types/operations/software.py | 50 + pa_api/xmlapi/types/statistics.py | 106 + pa_api/xmlapi/types/utils.py | 233 ++ pa_api/xmlapi/utils.py | 148 + poetry.lock | 506 +++ public/index.html | 7 + public/pa_api.html | 248 ++ public/pa_api/panorama.html | 531 +++ public/pa_api/restapi.html | 446 +++ public/pa_api/restapi/rest_resources.html | 2774 +++++++++++++ public/pa_api/restapi/restapi.html | 739 ++++ public/pa_api/xmlapi.html | 3461 +++++++++++++++++ public/pa_api/xmlapi/types.html | 272 ++ public/pa_api/xmlapi/types/config.html | 261 ++ .../pa_api/xmlapi/types/config/address.html | 799 ++++ .../xmlapi/types/config/devicegroup.html | 554 +++ .../pa_api/xmlapi/types/config/interface.html | 3452 ++++++++++++++++ .../pa_api/xmlapi/types/config/routing.html | 243 ++ .../types/config/routing/routing_table.html | 934 +++++ public/pa_api/xmlapi/types/config/rules.html | 247 ++ .../pa_api/xmlapi/types/config/rules/nat.html | 1778 +++++++++ .../xmlapi/types/config/rules/rulebase.html | 434 +++ .../xmlapi/types/config/rules/security.html | 1323 +++++++ public/pa_api/xmlapi/types/config/zone.html | 666 ++++ public/pa_api/xmlapi/types/operations.html | 247 ++ .../xmlapi/types/operations/device.html | 1976 ++++++++++ .../pa_api/xmlapi/types/operations/job.html | 794 ++++ .../xmlapi/types/operations/software.html | 548 +++ public/pa_api/xmlapi/types/statistics.html | 1355 +++++++ public/pa_api/xmlapi/types/utils.html | 1139 ++++++ public/search.js | 46 + pyproject.toml | 27 + requirements.txt | 327 ++ ruff.toml | 87 + tests/.gitkeep | 0 80 files changed, 30926 insertions(+) create mode 100644 .github/dependabot.yml create mode 100644 .github/workflows/docs.yml create mode 100644 .github/workflows/gitleaks.yml create mode 100644 .github/workflows/pre-commit.yml create mode 100644 .github/workflows/python-publish.yml create mode 100644 .gitignore create mode 100644 .pre-commit-config.yaml create mode 100644 .python-ci.yml create mode 100644 .python-version create mode 100644 .readthedocs.yaml create mode 100644 .semgrepignore create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 PaloAlto_API_Insight.md create mode 100644 README.md create mode 100644 examples/__init__.py create mode 100644 mypy.ini create mode 100644 pa_api/__init__.py create mode 100644 pa_api/__main__.py create mode 100644 pa_api/constants.py create mode 100644 pa_api/panorama.py create mode 100644 pa_api/restapi/__init__.py create mode 100644 pa_api/restapi/rest_resources.py create mode 100644 pa_api/restapi/restapi.py create mode 100644 pa_api/utils.py create mode 100644 pa_api/xmlapi/__init__.py create mode 100644 pa_api/xmlapi/base.py create mode 100644 pa_api/xmlapi/client.py create mode 100644 pa_api/xmlapi/constants.py create mode 100644 pa_api/xmlapi/objects.py create mode 100644 pa_api/xmlapi/types/__init__.py create mode 100644 pa_api/xmlapi/types/config/__init__.py create mode 100644 pa_api/xmlapi/types/config/address.py create mode 100644 pa_api/xmlapi/types/config/devicegroup.py create mode 100644 pa_api/xmlapi/types/config/interface.py create mode 100644 pa_api/xmlapi/types/config/routing/__init__.py create mode 100644 pa_api/xmlapi/types/config/routing/routing_table.py create mode 100644 pa_api/xmlapi/types/config/rules/__init__.py create mode 100644 pa_api/xmlapi/types/config/rules/nat.py create mode 100644 pa_api/xmlapi/types/config/rules/rulebase.py create mode 100644 pa_api/xmlapi/types/config/rules/security.py create mode 100644 pa_api/xmlapi/types/config/zone.py create mode 100644 pa_api/xmlapi/types/operations/__init__.py create mode 100644 pa_api/xmlapi/types/operations/device.py create mode 100644 pa_api/xmlapi/types/operations/job.py create mode 100644 pa_api/xmlapi/types/operations/software.py create mode 100644 pa_api/xmlapi/types/statistics.py create mode 100644 pa_api/xmlapi/types/utils.py create mode 100644 pa_api/xmlapi/utils.py create mode 100644 poetry.lock create mode 100644 public/index.html create mode 100644 public/pa_api.html create mode 100644 public/pa_api/panorama.html create mode 100644 public/pa_api/restapi.html create mode 100644 public/pa_api/restapi/rest_resources.html create mode 100644 public/pa_api/restapi/restapi.html create mode 100644 public/pa_api/xmlapi.html create mode 100644 public/pa_api/xmlapi/types.html create mode 100644 public/pa_api/xmlapi/types/config.html create mode 100644 public/pa_api/xmlapi/types/config/address.html create mode 100644 public/pa_api/xmlapi/types/config/devicegroup.html create mode 100644 public/pa_api/xmlapi/types/config/interface.html create mode 100644 public/pa_api/xmlapi/types/config/routing.html create mode 100644 public/pa_api/xmlapi/types/config/routing/routing_table.html create mode 100644 public/pa_api/xmlapi/types/config/rules.html create mode 100644 public/pa_api/xmlapi/types/config/rules/nat.html create mode 100644 public/pa_api/xmlapi/types/config/rules/rulebase.html create mode 100644 public/pa_api/xmlapi/types/config/rules/security.html create mode 100644 public/pa_api/xmlapi/types/config/zone.html create mode 100644 public/pa_api/xmlapi/types/operations.html create mode 100644 public/pa_api/xmlapi/types/operations/device.html create mode 100644 public/pa_api/xmlapi/types/operations/job.html create mode 100644 public/pa_api/xmlapi/types/operations/software.html create mode 100644 public/pa_api/xmlapi/types/statistics.html create mode 100644 public/pa_api/xmlapi/types/utils.html create mode 100644 public/search.js create mode 100644 pyproject.toml create mode 100644 requirements.txt create mode 100644 ruff.toml create mode 100644 tests/.gitkeep diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..9d866e3 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,11 @@ +# To get started with Dependabot version updates, you'll need to specify which +# package ecosystems to update and where the package manifests are located. +# Please see the documentation for all configuration options: +# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file + +version: 2 +updates: + - package-ecosystem: "pip" # See documentation for possible values + directory: "/" # Location of package manifests + schedule: + interval: "weekly" diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..80620b6 --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,51 @@ +# https://github.com/mitmproxy/pdoc/blob/main/.github/workflows/docs.yml +name: documentation + +# build the documentation whenever there are new commits on main +on: + push: + branches: + - main + # Alternative: only build for tags. + # tags: + # - '*' + +# security: restrict permissions for CI jobs. +permissions: + contents: read + +jobs: + # Build the documentation and upload the static HTML files as an artifact. + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.10' + + # ADJUST THIS: install all dependencies (including pdoc) + - run: pip install pdoc + - run: pip install -e . + # ADJUST THIS: build your documentation into docs/. + # We use a custom build script for pdoc itself, ideally you just run `pdoc -o docs/ ...` here. + - run: make docs + + - uses: actions/upload-pages-artifact@v3 + with: + path: public/ + + # Deploy the artifact to GitHub pages. + # This is a separate job so that only actions/deploy-pages has the necessary permissions. + deploy: + needs: build + runs-on: ubuntu-latest + permissions: + pages: write + id-token: write + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - id: deployment + uses: actions/deploy-pages@v4 diff --git a/.github/workflows/gitleaks.yml b/.github/workflows/gitleaks.yml new file mode 100644 index 0000000..23a4675 --- /dev/null +++ b/.github/workflows/gitleaks.yml @@ -0,0 +1,19 @@ +# https://github.com/gitleaks/gitleaks + +permissions: + contents: read + +name: gitleaks +on: [pull_request, push, workflow_dispatch] +jobs: + scan: + name: gitleaks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + with: + fetch-depth: 0 + - uses: gitleaks/gitleaks-action@v2 + # env: + # GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # GITLEAKS_LICENSE: ${{ secrets.GITLEAKS_LICENSE }} # Only required for Organizations, not personal accounts. diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml new file mode 100644 index 0000000..89a2054 --- /dev/null +++ b/.github/workflows/pre-commit.yml @@ -0,0 +1,45 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Run pre-commit scripts + +on: [pull_request, workflow_dispatch] + +permissions: + contents: read + +env: + PRE_COMMIT_HOME: pre-commit/ +jobs: + Checks: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - name: Cache Pre-commit environment + id: cache-pre-commit + uses: actions/cache@v3 + # https://stackoverflow.com/questions/60491837/saving-cache-on-job-failure-in-github-actions + # uses: actions/cache/save@v3 # actions/cache@v3 + # if: always() + with: + path: ${{ env.PRE_COMMIT_HOME }} + key: ${{ runner.os }}-pre-commit + restore-keys: | + ${{ runner.os }}-pre-commit + - name: Set up Python + uses: actions/setup-python@v3 + with: + python-version: '3.10' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install pre-commit + - name: Run pre-commit + run: pre-commit run -a diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml new file mode 100644 index 0000000..ad28f6e --- /dev/null +++ b/.github/workflows/python-publish.yml @@ -0,0 +1,37 @@ +# This workflow will upload a Python Package using Twine when a release is created +# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python#publishing-to-package-registries + +# This workflow uses actions that are not certified by GitHub. +# They are provided by a third-party and are governed by +# separate terms of service, privacy policy, and support +# documentation. + +name: Upload Python Package + +on: [pull_request, workflow_dispatch] + +permissions: + contents: read + +jobs: + deploy: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + - name: Set up Python + uses: actions/setup-python@v3 + with: + python-version: '3.x' + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish package + uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + with: + user: __token__ + password: ${{ secrets.PYPI_API_TOKEN }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..9705d84 --- /dev/null +++ b/.gitignore @@ -0,0 +1,175 @@ +.env +.vscode +output +.secrets + + +# =============================================================================================================== +# The following comes from here: +# https://github.com/github/gitignore/blob/main/Python.gitignore + + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + + + +# =============================================================================================================== diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..290c473 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,114 @@ +# See https://pre-commit.com for more information +# See https://pre-commit.com/hooks.html for more hooks +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: trailing-whitespace + exclude: ^public/ + - id: check-docstring-first + - id: check-added-large-files + - id: check-yaml + - id: debug-statements + - id: check-merge-conflict + + - id: end-of-file-fixer + exclude: ^public/ + + - repo: https://github.com/gitleaks/gitleaks + rev: v8.16.1 + hooks: + - id: gitleaks + + - repo: https://github.com/pre-commit/mirrors-mypy # https://github.com/python/mypy # Add static typing checks + rev: 'v1.10.0' + hooks: + - id: mypy + args: [--config-file, ./mypy.ini, --ignore-missing-imports] + + - repo: https://github.com/astral-sh/ruff-pre-commit + # Ruff version. + rev: v0.4.4 + hooks: + # Run the linter. + - id: ruff + args: [ --fix ] + # Run the formatter. + - id: ruff-format + + - repo: https://github.com/python-poetry/poetry + rev: '1.6.0' # add version here + hooks: + - id: poetry-check + - id: poetry-lock + - id: poetry-export + + - repo: https://github.com/PyCQA/bandit + rev: 1.7.8 + hooks: + - id: bandit # Nb: .bandit file is ignore by pre-commit hook + # args: [--skip, "B320,B410", --recursive, clumper] + + # https://github.com/bridgecrewio/checkov/issues/5841 + - repo: https://github.com/bridgecrewio/checkov.git + rev: 3.2.194 + hooks: + - id: checkov + - id: checkov_diff + - id: checkov_secrets + + # - repo: https://github.com/bridgecrewio/checkov + # rev: 3.1.16 + # hooks: + # - id: checkov_diff + # - id: checkov_secrets + + - repo: https://github.com/semgrep/semgrep + rev: v1.73.0 + hooks: + - id: semgrep + exclude: ^public/ + # This uses the Python "hook" in .pre-commit-hooks.yaml and setup.py. + # alt: use 'repo: local', and 'language: docker', which can use + # the very latest docker image, which is nice, but is far slower. + + language: python + + + # Both the .semgrepignore file and the --exclude option + # do nothing because the target files are passed + # explicitly on the command line by pre-commit! + args: [ + # use osemgrep! + #"--experimental", + # use jsonnet! + # "--config", "semgrep.jsonnet", + # classic flag to use in CI or pre-commit, return error code if findings + "--quiet", + "--error", + # "--strict", + # "--exclude='examples/*", + #"--verbose", + "--skip-unknown-extensions", + # "--metrics=off", + ] + + + +# black is an opiniated formatter +# - repo: https://github.com/ambv/black +# rev: 23.9.1 +# hooks: +# - id: black +# # language_version: python3.6 + + +# When adding a new hook, we may need to run +# `pre-commit run --all-files` +# right after installing the hook (`pre-commit install`) +# https://stackoverflow.com/questions/54697699/how-to-propertly-configure-my-pre-commit-and-pre-push-hooks +# - repo: https://github.com/google/yapf +# rev: v0.40.2 +# hooks: +# - id: yapf + # exclude: ^hello\.*\.py$ diff --git a/.python-ci.yml b/.python-ci.yml new file mode 100644 index 0000000..c5f15f5 --- /dev/null +++ b/.python-ci.yml @@ -0,0 +1,34 @@ +# https://docs.gitlab.com/ee/user/packages/pypi_repository/#authenticate-with-a-ci-job-token +image: python:3.10 +stages: + - lint + - deploy + +publish_local: + stage: deploy + script: + - pip install build twine + - python -m build + - TWINE_PASSWORD=${CI_JOB_TOKEN} TWINE_USERNAME=gitlab-ci-token python -m twine upload --repository-url ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/pypi dist/* + rules: + # This task requires a lot of installation and should have ran locally before the commit + # We should only be needing this check before the merge request on the default branch + - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"' + # Nb: push shouldn't be allowed on master + - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "main"' + +publish_pypi: + stage: deploy + script: + - pip install build twine + - python -m build + - TWINE_PASSWORD=${PYPI_TOKEN} TWINE_USERNAME=__token__ python -m twine upload dist/* + rules: + # This task requires a lot of installation and should have ran locally before the commit + # We should only be needing this check before the merge request on the default branch + - if: '$CI_PIPELINE_SOURCE == "merge_request_event" && $CI_MERGE_REQUEST_TARGET_BRANCH_NAME == "main"' + # Nb: push shouldn't be allowed on master + - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH == "main"' + +# TODO: Check if the version of the package was updated before the merge +# (i.e. doesn't exist in the registry) diff --git a/.python-version b/.python-version new file mode 100644 index 0000000..c8cfe39 --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.10 diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..015eb5d --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,19 @@ +# Read the Docs configuration file for MkDocs projects +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the version of Python and other tools you might need +build: + os: ubuntu-22.04 + tools: + python: "3.12" + +mkdocs: + configuration: mkdocs.yml + +# Optionally declare the Python requirements required to build your docs +python: + install: + - requirements: docs/requirements.txt diff --git a/.semgrepignore b/.semgrepignore new file mode 100644 index 0000000..e39721e --- /dev/null +++ b/.semgrepignore @@ -0,0 +1 @@ +examples/* diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..13a77ef --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2024 David Gallay + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..f32f63f --- /dev/null +++ b/Makefile @@ -0,0 +1,11 @@ +docs: + # See Pdoc for documentation generation + # public contains gitlab's pages + # https://docs.gitlab.com/ee/user/project/pages/#how-it-works + python3.10 -m pdoc ./pa_api/ -o ./public/ +isolate: + docker run -it --rm -w '/workdir' -v "$$PWD:/workdir" python:3.10 bash + # NOTE: You might want to run the following in the container: + # # Allow using git based on the active directory (necessary for pre-commit) + # - git config --global --add safe.directory /workdir + # - pip install pre-commit poetry diff --git a/PaloAlto_API_Insight.md b/PaloAlto_API_Insight.md new file mode 100644 index 0000000..6171f06 --- /dev/null +++ b/PaloAlto_API_Insight.md @@ -0,0 +1,67 @@ +# PaloAlto API: Insight + +## Existing tools + +### Migration tool + +[Expedition](https://live.paloaltonetworks.com/t5/expedition/ct-p/migration_tool) is the 4th version of migration tool and can apparently delete [all unused objects](https://live.paloaltonetworks.com/t5/automation-api-discussions/how-to-quickly-find-and-remove-unused-objects-in-policy/td-p/230055). It is worth trying to use this tool if a cli is available. + +### Libraries + +* [pan-os-python](https://github.com/PaloAltoNetworks/pan-os-python): Developped by PaloAltoNetworks. The library is maintained but it is really not practical to use. It is subdocumented and strange to use. + + ```python + from panos.panorama import Panorama + from panos.objects import AddressObject + + pano = Panorama(hn, un, pw) + + # You need to give the direct parent + # and explicitly retrieve the data manually + AddressObject.refreshall(pano) + + # Before being able to use it + addr = pano.findall(AddressObject) + ``` + + * [How to get all shared address object](https://github.com/PaloAltoNetworks/pan-os-python/issues/427) + + * [Documentation - HowTo](https://github.com/PaloAltoNetworks/pan-os-python/blob/develop/docs/howto.rst) + + * [Code Sample: Ensure security rule](https://github.com/PaloAltoNetworks/pan-os-python/blob/master/examples/ensure_security_rule.py) +- [pan-python](https://github.com/kevinsteves/pan-python/tree/master): wrapper for the XML API. (The [documentation](http://api-lab.paloaltonetworks.com/pan-python.html) seems to be hosted by PaloAltoNetworks) + +### Client + +* [pan-configurator](https://github.com/cpainchaud/pan-configurator) ? + +* [panxapi](https://github.com/kevinsteves/pan-python/blob/master/doc/panxapi.rst) python client for the xml api. It does not do much more. + +## Existing APIs + +* **REST API**: We access the resources directly. + +* **XML API**: We traverse an xml configuration containing all informations using xpath. + This seems to be the most powerful API + + * [Explore the API](https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-xml-api/explore-the-api#id32696dff-45b0-40c6-abdf-ef7fbe8a6604): We can explore the API, e.g. through the [browser](https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-xml-api/explore-the-api/use-the-api-browser#id676e85fa-1823-466a-9e31-269dc6eb433a) + + * [Configuration (API) ](https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api) + + * [Use XPath to Get Active Configuration](https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/get-active-configuration/use-xpath-to-get-active-configuration#:~:text=Use%20action%3Dshow%20with%20no%20additional%20parameters%20to%20retrieve,example%2C%20to%20retrieve%20just%20the%20security%20rulebase%3A%20xpath%3D%2Fconfig%2Fdevices%2Fentry%2Fvsys%2Fentry%2Frulebase%2Fsecurity) + + We can for example find the `entry` referencing an object as a member + + ```python + /config/devices/entry/device-group//member[text() = 'RAR_ZRH-SNAT_Subnet']//ancestor::entry[position() = 1] + ``` + + Nb: this is usefull to find the dependencies, but it is not easy to delete this entry + +### Other informations + +* [security policy filtering](https://live.paloaltonetworks.com/t5/blogs/tips-and-tricks-filtering-the-security-policy/ba-p/163250): it is apparently possible to filter the policies according to their members + +* [XML API walkthrough](https://blr-pan-01.hq.k.grp/php/rest/browse.php/config%3A%3Adevices%3A%3Aentry%5B%40name%3D%27localhost%252Elocaldomain%27%5D%3A%3Adevice-group) + +* [Embedded REST API documentation](https://blr-pan-01.hq.k.grp/restapi-doc/#tag/objects-addresses) diff --git a/README.md b/README.md new file mode 100644 index 0000000..e96481c --- /dev/null +++ b/README.md @@ -0,0 +1,55 @@ +# README + +This repository contains a wrapper around Panorama/PaloAlto API. +It also provides a cli tool: `pa-api`. + + +## Why the need for this library ? + +For simple resource retrieval, the existing API is enough, but the libraries available are not practical for it. +Especially, we don't have much information on the data' schema. + +The [official python SDK of PaloAltoNetworks](https://github.com/PaloAltoNetworks/pan-os-python) itself relies on a [third party wrapper](https://github.com/kevinsteves/pan-python) for their API. + + +This library provides clients (JSON/XML APIs) with a more popular approach when wrapping the API, making it easier to use for developers. It also provides types' wrappers using [pydantic](https://docs.pydantic.dev/latest/) library to simplify their usage or utility functions to re-structure the data we receive. This provides the usual benefits of types like: +* IDE completion: IDE will be able to provide you with completion as you type your code +* Consistancy: a value that might be missing will always be defined either as `None` or as an empty list +* Correctness: using `mypy`, you will be able to catch errors before they go to production. + +NOTE: The json API is very limited and is, in fact, a mere translation of the xml using the same process as `xmltodict` library. +Also, it is quite slow. For big read operations, it is better to retrieve big portions of the configuration at once and work completely locally. + + +## Current State of the library + +This library was developed over months by adding features when they were needed. +It was tested against 9.x to 11.x paloalto and panorama devices. + +There are a few caveats though: +* Not everything is done now +* The main focus is put on the XML API (there is no real reason to use the json API with this library) +* The distinction between paloalto and panorama is not clearly defined everywhere. + NOTE: we are trying to make the distinction transparent. +* It currently focus on data retrieval more than insertion/update/deletion. +* Methods should be re-arranged and re-grouped to simplify the usage of the library. +* This does not support async/await currently. + +Contributions are welcome: +* Completing / Correcting types is more than welcome +* Bug fixes are also very welcome +* We would also like people opinions on how we can improve the library: + * How should we organize the client classes and methods + * How the creation/update/deletion should be taken care + Don't hesitate to open an issue/discussion on this topic. + +## TODO + +* Improve the documentation + * Re-organize the methods + +* # Mix Rest API and XML API ? (at least for create/update/delete ?) + https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/create-security-policy-rule-rest-api + + +## Links diff --git a/examples/__init__.py b/examples/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/mypy.ini b/mypy.ini new file mode 100644 index 0000000..b98652d --- /dev/null +++ b/mypy.ini @@ -0,0 +1,17 @@ +# Global options: + +[mypy] +; warn_return_any = True +warn_unused_configs = True +ignore_missing_imports = True +warn_return_any = False +disallow_untyped_defs = True +allow_untyped_defs = True +allow_untyped_calls = True +allow_redefinition = True +# https://mypy.readthedocs.io/en/stable/config_file.html#confval-disable_error_code +disable_error_code = var-annotated,import-untyped + + +# Per-module options: +; [mypy-mycode.foo.*] diff --git a/pa_api/__init__.py b/pa_api/__init__.py new file mode 100644 index 0000000..9de27f5 --- /dev/null +++ b/pa_api/__init__.py @@ -0,0 +1,10 @@ +from . import panorama, restapi, xmlapi +from .panorama import Panorama +from .restapi.restapi import PanoramaClient +from .xmlapi import XMLApi, types + +__all__ = [ + "panorama", + "restapi", + "xmlapi", +] diff --git a/pa_api/__main__.py b/pa_api/__main__.py new file mode 100644 index 0000000..95b88f5 --- /dev/null +++ b/pa_api/__main__.py @@ -0,0 +1,11 @@ +import logging + +from pa_api.commands.utils import set_default_logger + +from .commands import cli + +set_default_logger() +logging.getLogger().setLevel(logging.INFO) + +if __name__ == "__main__": + cli() diff --git a/pa_api/constants.py b/pa_api/constants.py new file mode 100644 index 0000000..e93ee57 --- /dev/null +++ b/pa_api/constants.py @@ -0,0 +1,41 @@ +# https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/pan-os-rest-api-error-codes +PANORAMA_ERRORS = { + 1: "The operation was canceled, typically by the caller.", + 2: "Unknown internal server error.", + 3: "Bad request. The caller specified an invalid parameter.", + 4: ( + "Gateway timeout. A firewall or Panorama module timed out " + "before a backend operation completed." + ), + 5: "Not found. The requested entity was not found.", + 6: "Conflict. The entity that the caller attempted to create already exists.", + 7: ( + "Forbidden. The caller does not have permission " + "to execute the specified operation." + ), + 8: "Resource exhausted. Some resource has been exhausted.", + 9: ( + "Failed precondition. The operation was rejected because the system" + " is not in a state required for the execution of the operation." + ), + 10: "Aborted because of conflict. A typical cause is a concurrency issue.", + 11: ( + "Out of range. The operation was attempted past a valid range." + " And example is reaching an end-of-file." + ), + 12: ( + "Not implemented. The operation is disabled," + " not implemented, or not supported." + ), + 13: ( + "Internal server error. An unexpected and potentially" + "serious internal error occurred." + ), + 14: "Service unavailable. The service is temporarily unavailable.", + 15: ("Internal server error. Unrecoverable data loss or data corruption occurred."), + 16: ( + "Unauthorized. The request does not have valid authentication" + "credentials to perform the operation." + ), +} +SUCCESS_CODE = 19 diff --git a/pa_api/panorama.py b/pa_api/panorama.py new file mode 100644 index 0000000..05d1777 --- /dev/null +++ b/pa_api/panorama.py @@ -0,0 +1,33 @@ +from panos import panorama + +from .utils import clean_url_host + + +class Panorama(panorama.Panorama): + """ + Wrapper class for the Panorama class from pan-os-python library: + https://pan-os-python.readthedocs.io/en/latest/readme.html#features + + Added features are: + - hostname can be provided with and without the scheme + - https://mydomain.com + - mydomain.com + - https://mydomain.com:443 + Are all valid + """ + + def __init__( + self, + hostname, + api_username=None, + api_password=None, + api_key=None, + port=None, + *args, + **kwargs, + ): + _, hostname, _port = clean_url_host(hostname) + port = port or _port or 443 + return super().__init__( + hostname, api_username, api_password, api_key, port, *args, **kwargs + ) diff --git a/pa_api/restapi/__init__.py b/pa_api/restapi/__init__.py new file mode 100644 index 0000000..53ce79f --- /dev/null +++ b/pa_api/restapi/__init__.py @@ -0,0 +1,8 @@ +from . import rest_resources, restapi +from .restapi import PanoramaClient + +__all__ = [ + "restapi", + "rest_resources", + "PanoramaClient", +] diff --git a/pa_api/restapi/rest_resources.py b/pa_api/restapi/rest_resources.py new file mode 100644 index 0000000..2c2ac22 --- /dev/null +++ b/pa_api/restapi/rest_resources.py @@ -0,0 +1,419 @@ +from functools import wraps +from multiprocessing.pool import ThreadPool as Pool +from typing import ClassVar + +# List of existing resources +# https://docs.paloaltonetworks.com/pan-os/10-2/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api + +DEFAULT_PARAMS = { + "location": "device-group", +} + + +class BasePanoramaResource: + def __init__( + self, + client, + host, + resource_type, + resource, + version="v10.1", + default_params=None, + ): + """ + client: + """ + self.DEFAULT_PARAMS = default_params or DEFAULT_PARAMS + if not host.startswith("http"): + host = "https://" + host + self._client = client + self._name = f"{resource_type}/{resource}" + self._url = f"{host}/restapi/{version}/{resource_type}/{resource}" + + def __str__(self): + return self._name + + def __repr__(self): + return str(self) + + def get(self, params=None, headers=None, data=None, verify=None): + return self._client.get( + self._url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + + def delete(self, params=None, headers=None, data=None, verify=None): + return self._client.delete( + self._url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + + +class PanoramaResource(BasePanoramaResource): + def get( + self, + device_group=None, + name=None, + inherited=True, + params=None, + headers=None, + data=None, + verify=None, + ): + if params is None: + params = {} + _params = {**self.DEFAULT_PARAMS, **params} + if name is not None: + _params["name"] = name + + def func(params): + params = {**_params, **params} + res = self._client.get( + self._url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + if not isinstance(res, list): + return [] # Error happened + if not inherited: + res = [r for r in res if r["@device-group"] == r["@loc"]] + return res + + if device_group is None: + return func(params) + if isinstance(device_group, str): + device_group = [device_group] + if len(device_group) == 1: + params = {"device-group": device_group} + return func(params) + if len(device_group) > 1: + params_list = [{"device-group": dg} for dg in device_group] + with Pool(len(device_group)) as pool: + data = pool.map(func, params_list) + return [record for res in data for record in res] + return None + + def delete( + self, + device_group=None, + name=None, + params=None, + headers=None, + data=None, + verify=None, + ): + if params is None: + params = {} + params = {**self.DEFAULT_PARAMS, **params} + if device_group is not None: + params["device-group"] = device_group + if name is not None: + params["name"] = name + return self._client.delete( + self._url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + + +class GroupedResources: + def __init__(self, *resources): + self._resources = resources + + def _grouped(self, method, *args, **kwargs): + params_list = [(getattr(r, method), args, kwargs) for r in self._resources] + + def func(args): + f, args, kwargs = args + return f(*args, **kwargs) + + with Pool(len(self._resources)) as pool: + data = pool.map(func, params_list) + return [record for res in data for record in res] + + @wraps(PanoramaResource.get) + def get(self, *args, **kwargs): + return self._grouped("get", *args, **kwargs) + + # def delete(self, params={}, headers={}, data=None, verify=None): + # return self._client.delete( + # self._url, + # params=params, headers=headers, + # data=data, verify=verify + # ) + + +class PanoramaResourceType: + def __init__(self, client, resource_type): + self._client = client + self._name = resource_type + + def __str__(self): + return self._name + + def __repr__(self): + return str(self) + + +class PanoramaPanoramaResourceType(PanoramaResourceType): + resource_type = "Panorama" + + def __init__(self, client, domain, version="v10.1"): + resource_type = self.resource_type + super().__init__(client, resource_type) + + def resource(name): + return BasePanoramaResource( + client, + domain, + resource_type, + name, + version=version, + ) + + self.DeviceGroups = resource("DeviceGroups") + + +class PanoramaObjectsResourceType(PanoramaResourceType): + """ + Represent the 'Objects' subsection in the API. + """ + + resource_type = "Objects" + + def __init__(self, client, domain, version="v10.1"): + resource_type = self.resource_type + super().__init__(client, resource_type) + + def resource(name): + return PanoramaResource( + client, + domain, + resource_type, + name, + version=version, + ) + + self.Addresses = resource("Addresses") + self.AddressGroups = resource("AddressGroups") + self.Regions = resource("Regions") + self.Applications = resource("Applications") + self.ApplicationGroups = resource("ApplicationGroups") + self.ApplicationFilters = resource("ApplicationFilters") + self.Services = resource("Services") + self.ServiceGroups = resource("ServiceGroups") + self.Tags = resource("Tags") + self.GlobalProtectHIPObjects = resource("GlobalProtectHIPObjects") + self.GlobalProtectHIPProfiles = resource("GlobalProtectHIPProfiles") + self.ExternalDynamicLists = resource("ExternalDynamicLists") + self.CustomDataPatterns = resource("CustomDataPatterns") + self.CustomSpywareSignatures = resource("CustomSpywareSignatures") + self.CustomVulnerabilitySignatures = resource("CustomVulnerabilitySignatures") + self.CustomURLCategories = resource("CustomURLCategories") + self.AntivirusSecurityProfiles = resource("AntivirusSecurityProfiles") + self.AntiSpywareSecurityProfiles = resource("AntiSpywareSecurityProfiles") + self.VulnerabilityProtectionSecurityProfiles = resource( + "VulnerabilityProtectionSecurityProfiles", + ) + self.URLFilteringSecurityProfiles = resource("URLFilteringSecurityProfiles") + self.FileBlockingSecurityProfiles = resource("FileBlockingSecurityProfiles") + self.WildFireAnalysisSecurityProfiles = resource( + "WildFireAnalysisSecurityProfiles", + ) + self.DataFilteringSecurityProfiles = resource("DataFilteringSecurityProfiles") + self.DoSProtectionSecurityProfiles = resource("DoSProtectionSecurityProfiles") + self.SecurityProfileGroups = resource("SecurityProfileGroups") + self.LogForwardingProfiles = resource("LogForwardingProfiles") + self.AuthenticationEnforcements = resource("AuthenticationEnforcements") + self.DecryptionProfiles = resource("DecryptionProfiles") + self.DecryptionForwardingProfiles = resource("DecryptionForwardingProfiles") + self.Schedules = resource("Schedules") + self.SDWANPathQualityProfiles = resource("SDWANPathQualityProfiles") + self.SDWANTrafficDistributionProfiles = resource( + "SDWANTrafficDistributionProfiles", + ) + + +class PanoramaPoliciesResourceType(PanoramaResourceType): + """ + Represent the 'Policies' subsection in the API. + """ + + resource_type = "Policies" + + def __init__(self, client, domain, version="v10.1"): + resource_type = self.resource_type + super().__init__(client, resource_type) + + def resource(name): + return PanoramaResource( + client, + domain, # host + resource_type, + name, + version=version, + ) + + self.SecurityPreRules = resource("SecurityPreRules") + self.SecurityPostRules = resource("SecurityPostRules") + self.SecurityRules = GroupedResources( + self.SecurityPreRules, + self.SecurityPostRules, + ) + self.NATPreRules = resource("NATPreRules") + self.NATPostRules = resource("NATPostRules") + self.NATRules = GroupedResources(self.NATPreRules, self.NATPostRules) + self.QoSPreRules = resource("QoSPreRules") + self.QoSPostRules = resource("QoSPostRules") + self.QoSRules = GroupedResources(self.QoSPreRules, self.QoSPostRules) + self.PolicyBasedForwardingPreRules = resource("PolicyBasedForwardingPreRules") + self.PolicyBasedForwardingPostRules = resource("PolicyBasedForwardingPostRules") + self.PolicyBasedForwardingRules = GroupedResources( + self.PolicyBasedForwardingPreRules, + self.PolicyBasedForwardingPostRules, + ) + self.DecryptionPreRules = resource("DecryptionPreRules") + self.DecryptionPostRules = resource("DecryptionPostRules") + self.DecryptionRules = GroupedResources( + self.DecryptionPreRules, + self.DecryptionPostRules, + ) + self.TunnelInspectionPreRules = resource("TunnelInspectionPreRules") + self.TunnelInspectionPostRules = resource("TunnelInspectionPostRules") + self.TunnelInspectionRules = GroupedResources( + self.TunnelInspectionPreRules, + self.TunnelInspectionPostRules, + ) + self.ApplicationOverridePreRules = resource("ApplicationOverridePreRules") + self.ApplicationOverridePostRules = resource("ApplicationOverridePostRules") + self.ApplicationOverrideRules = GroupedResources( + self.ApplicationOverridePreRules, + self.ApplicationOverridePostRules, + ) + self.AuthenticationPreRules = resource("AuthenticationPreRules") + self.AuthenticationPostRules = resource("AuthenticationPostRules") + self.AuthenticationRules = GroupedResources( + self.AuthenticationPreRules, + self.AuthenticationPostRules, + ) + self.DoSPreRules = resource("DoSPreRules") + self.DoSPostRules = resource("DoSPostRules") + self.DoSRules = GroupedResources(self.DoSPreRules, self.DoSPostRules) + self.SDWANPreRules = resource("SDWANPreRules") + self.SDWANPostRules = resource("SDWANPostRules") + self.SDWANRules = GroupedResources(self.SDWANPreRules, self.SDWANPostRules) + + +class PanoramaNetworkResourceType(PanoramaResourceType): + """ + Represent the 'Network' subsection in the API. + """ + + DEFAULT_PARAMS: ClassVar = { + "location": "template", + } + resource_type = "Network" + + def __init__(self, client, domain, version="v10.1"): + resource_type = self.resource_type + super().__init__(client, resource_type) + + def resource(name): + return PanoramaResource( + client, + domain, + resource_type, + name, + version=version, + default_params=self.DEFAULT_PARAMS, + ) + + self.EthernetInterfaces = resource("EthernetInterfaces") + self.AggregateEthernetInterfaces = resource("AggregateEthernetInterfaces") + self.VLANInterfaces = resource("VLANInterfaces") + self.LoopbackInterfaces = resource("LoopbackInterfaces") + self.TunnelIntefaces = resource("TunnelIntefaces") + self.SDWANInterfaces = resource("SDWANInterfaces") + self.Zones = resource("Zones") + self.VLANs = resource("VLANs") + self.VirtualWires = resource("VirtualWires") + self.VirtualRouters = resource("VirtualRouters") + self.IPSecTunnels = resource("IPSecTunnels") + self.GRETunnels = resource("GRETunnels") + self.DHCPServers = resource("DHCPServers") + self.DHCPRelays = resource("DHCPRelays") + self.DNSProxies = resource("DNSProxies") + self.GlobalProtectPortals = resource("GlobalProtectPortals") + self.GlobalProtectGateways = resource("GlobalProtectGateways") + self.GlobalProtectGatewayAgentTunnels = resource( + "GlobalProtectGatewayAgentTunnels", + ) + self.GlobalProtectGatewaySatelliteTunnels = resource( + "GlobalProtectGatewaySatelliteTunnels", + ) + self.GlobalProtectGatewayMDMServers = resource("GlobalProtectGatewayMDMServers") + self.GlobalProtectClientlessApps = resource("GlobalProtectClientlessApps") + self.GlobalProtectClientlessAppGroups = resource( + "GlobalProtectClientlessAppGroups", + ) + self.QoSInterfaces = resource("QoSInterfaces") + self.LLDP = resource("LLDP") + self.GlobalProtectIPSecCryptoNetworkProfiles = resource( + "GlobalProtectIPSecCryptoNetworkProfiles", + ) + self.IKEGatewayNetworkProfiles = resource("IKEGatewayNetworkProfiles") + self.IKECryptoNetworkProfiles = resource("IKECryptoNetworkProfiles") + self.MonitorNetworkProfiles = resource("MonitorNetworkProfiles") + self.InterfaceManagementNetworkProfiles = resource( + "InterfaceManagementNetworkProfiles", + ) + self.ZoneProtectionNetworkProfiles = resource("ZoneProtectionNetworkProfiles") + self.QoSNetworkProfiles = resource("QoSNetworkProfiles") + self.LLDPNetworkProfiles = resource("LLDPNetworkProfiles") + self.SDWANInterfaceProfiles = resource("SDWANInterfaceProfiles") + + +class PanoramaDevicesResourceType(PanoramaResourceType): + """ + Represent the 'Devices' subsection in the API. + """ + + DEFAULT_PARAMS: ClassVar = { + "location": "template", + } + resource_type = "Device" + + def __init__(self, client, domain, version="v10.1"): + resource_type = self.resource_type + super().__init__(client, resource_type) + + def resource(name): + return PanoramaResource( + client, + domain, + resource_type, + name, + version=version, + default_params=self.DEFAULT_PARAMS, + ) + + self.VirtualSystems = resource("VirtualSystems") + + +__all__ = [ + "PanoramaDevicesResourceType", + "PanoramaNetworkResourceType", + "PanoramaObjectsResourceType", + "PanoramaPanoramaResourceType", + "PanoramaPoliciesResourceType", +] diff --git a/pa_api/restapi/restapi.py b/pa_api/restapi/restapi.py new file mode 100644 index 0000000..fca404e --- /dev/null +++ b/pa_api/restapi/restapi.py @@ -0,0 +1,306 @@ +import json +import logging +from itertools import chain + +import requests + +# Remove warning for unverified certificate +# https://stackoverflow.com/questions/27981545/suppress-insecurerequestwarning-unverified-https-request-is-being-made-in-pytho +from requests.packages.urllib3.exceptions import InsecureRequestWarning + +from pa_api.constants import PANORAMA_ERRORS, SUCCESS_CODE +from pa_api.utils import clean_url_host + +from .rest_resources import ( + PanoramaDevicesResourceType, + PanoramaNetworkResourceType, + PanoramaObjectsResourceType, + PanoramaPanoramaResourceType, + PanoramaPoliciesResourceType, +) + +requests.packages.urllib3.disable_warnings(InsecureRequestWarning) + +OBJECT_RESOURCES = [ + "Addresses", + "AddressGroups", + "Regions", + "Applications", + "ApplicationGroups", + "ApplicationFilters", + "Services", + "ServiceGroups", + "Tags", + "GlobalProtectHIPObjects", + "GlobalProtectHIPProfiles", + "ExternalDynamicLists", + "CustomDataPatterns", + "CustomSpywareSignatures", + "CustomVulnerabilitySignatures", + "CustomURLCategories", + "AntivirusSecurityProfiles", + "AntiSpywareSecurityProfiles", + "VulnerabilityProtectionSecurityProfiles", + "URLFilteringSecurityProfiles", + "FileBlockingSecurityProfiles", + "WildFireAnalysisSecurityProfiles", + "DataFilteringSecurityProfiles", + "DoSProtectionSecurityProfiles", + "SecurityProfileGroups", + "LogForwardingProfiles", + "AuthenticationEnforcements", + "DecryptionProfiles", + "DecryptionForwardingProfiles", + "Schedules", + "SDWANPathQualityProfiles", + "SDWANTrafficDistributionProfiles", +] + +POLICY_RESOURCES = [ + "SecurityRules", + "NATRules", + "QoSRules", + "PolicyBasedForwardingRules", + "DecryptionRules", + "TunnelInspectionRules", + "ApplicationOverrideRules", + "AuthenticationRules", + "DoSRules", + "SDWANRules", +] + +NETWORK_RESOURCES = [ + "EthernetInterfaces", + "AggregateEthernetInterfaces", + "VLANInterfaces", + "LoopbackInterfaces", + "TunnelIntefaces", + "SDWANInterfaces", + "Zones", + "VLANs", + "VirtualWires", + "VirtualRouters", + "IPSecTunnels", + "GRETunnels", + "DHCPServers", + "DHCPRelays", + "DNSProxies", + "GlobalProtectPortals", + "GlobalProtectGateways", + "GlobalProtectGatewayAgentTunnels", + "GlobalProtectGatewaySatelliteTunnels", + "GlobalProtectGatewayMDMServers", + "GlobalProtectClientlessApps", + "GlobalProtectClientlessAppGroups", + "QoSInterfaces", + "LLDP", + "GlobalProtectIPSecCryptoNetworkProfiles", + "IKEGatewayNetworkProfiles", + "IKECryptoNetworkProfiles", + "MonitorNetworkProfiles", + "InterfaceManagementNetworkProfiles", + "ZoneProtectionNetworkProfiles", + "QoSNetworkProfiles", + "LLDPNetworkProfiles", + "SDWANInterfaceProfiles", +] + +DEVICE_RESOURCES = [ + "VirtualSystems", +] + +DEFAULT_PARAMS = { + "output-format": "json", +} + + +class PanoramaAPI: + def __init__(self, api_key=None, verbose=False, verify=False, logger=None): + self._verbose = verbose + self._verify = verify + self._api_key = api_key + self.logger = logger or logging + + def _inner_request( + self, + method, + url, + params=None, + headers=None, + data=None, + verify=None, + ): + if params is None: + params = {} + if headers is None: + headers = {} + if verify is None: + verify = self._verify + default_headers = { + "X-PAN-KEY": self._api_key, + # 'Accept': 'application/json, application/xml', + # 'Content-Type': 'application/json' + } + headers = {**default_headers, **headers} + params = {**DEFAULT_PARAMS, **params} + res = requests.request( + method, + url, + params=params, + headers=headers, + verify=verify, + ) + # The API always returns a json, no matter what + # if not res.ok: + # return None + try: + data = res.json() + code = int( + data.get("@code") or data.get("code") or SUCCESS_CODE, + ) # Sometimes, the code is a string, some other times it is a int + status = data.get("@status", "") + success = status == "success" + error_occured = ( + not res.ok + or ( + not success and code < SUCCESS_CODE + ) # In case of success, the value 19 is used + ) + if not error_occured: + return data, None + message = ( + data.get("message") + or PANORAMA_ERRORS.get(data["@code"]) + or "Something happened: " + json.dumps(data) + ) + error = f"(CODE: {code}) {message}" + if self._verbose: + causes = list( + chain( + *( + details.get("causes", {}) + for details in data.get("details", []) + ), + ), + ) + details = "".join(c.get("description") for c in causes) + error = f"{error} {details}" + return data, error + except Exception as e: + return None, str(e) + + def _request( + self, + method, + url, + params=None, + headers=None, + data=None, + verify=None, + no_exception=False, + ): + data, error = ( + self._inner_request( + method, + url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + or {} + ) + if error: + if no_exception: + self.logger.error(f"Could not {method.lower()} {url}: {error}") + return data, error + raise Exception(error) + data = data.get("result", {}).get("entry") or [] + return data, error + + def request(self, method, url, params=None, headers=None, data=None, verify=None): + data, _ = ( + self._request( + method, + url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + or {} + ) + return data + + def get(self, url, params=None, headers=None, data=None, verify=None): + data, _ = ( + self._request( + "GET", + url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + or {} + ) + return data + # return data.get("result", {}).get("entry") or [] + + def delete(self, url, params=None, headers=None, data=None, verify=None): + data, _ = ( + self._request( + "DELETE", + url, + params=params, + headers=headers, + data=data, + verify=verify, + ) + or {} + ) + return data + + +class PanoramaClient: + """ + Wrapper for the PaloAlto REST API + Resources (e.g. Addresses, Tags, ..) are grouped under their resource types. + See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4 + + Attributes: + + - objects: groups all the objects (Address, Tag, Service, ...) + - policies: groups all the policies (Security, NAT, ...) + - network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...) + - device: groups all device-related resources (only VirtualSystems) + - panorama: groups all panorama-management-related resources (only DeviceGroups) + """ + + objects: PanoramaObjectsResourceType + policies: PanoramaPoliciesResourceType + network: PanoramaNetworkResourceType + device: PanoramaDevicesResourceType + panorama: PanoramaPanoramaResourceType + + def __init__( + self, + domain, + api_key=None, + version="v10.1", + verify=False, + verbose=False, + ): + domain, _, _ = clean_url_host(domain) + client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify) + self.client = client + self.objects = PanoramaObjectsResourceType(client, domain, version=version) + self.policies = PanoramaPoliciesResourceType(client, domain, version=version) + self.network = PanoramaNetworkResourceType(client, domain, version=version) + self.device = PanoramaDevicesResourceType(client, domain, version=version) + self.panorama = PanoramaPanoramaResourceType(client, domain, version=version) + + +__all__ = [ + "PanoramaClient", +] diff --git a/pa_api/utils.py b/pa_api/utils.py new file mode 100644 index 0000000..d61ad56 --- /dev/null +++ b/pa_api/utils.py @@ -0,0 +1,47 @@ +import os +import re + +URL_REG = re.compile("(http://|https://)?([^:/]*)(?::(\d+))?(/.*)?") + + +def first(iterable, default=None): + return next(iter(iterable), default) + + +def clean_url_host(url): + """ + Clean the url: + * Add scheme if missing + * Remove trailing slash and path + * Extract the host + """ + scheme, host, port, _ = URL_REG.match(url).groups() + scheme = scheme or "https://" + url = scheme + host + (f":{port}" if port else "") + return url, host, port + + +# ============================================= +def getenv(*varnames, raise_exception=True, default=None): + for var in varnames: + val = os.environ.get(var) + if val is not None: + return val.strip() + if raise_exception: + raise Exception( + f"None of the following environment variables are defined: {', '.join(varnames)}" + ) + return default + + +# ======================================================================================================= + + +def get_credentials_from_env(raise_exception=False): + host = getenv( + "PA_HOST", "PANO_HOST", "PANORAMA_HOST", raise_exception=raise_exception + ) + apikey = getenv( + "PA_APIKEY", "PANO_APIKEY", "PANORAMA_APIKEY", raise_exception=raise_exception + ) + return host, apikey diff --git a/pa_api/xmlapi/__init__.py b/pa_api/xmlapi/__init__.py new file mode 100644 index 0000000..8e21331 --- /dev/null +++ b/pa_api/xmlapi/__init__.py @@ -0,0 +1,7 @@ +from . import types +from .client import XMLApi + +__all__ = [ + "XMLApi", + "types", +] diff --git a/pa_api/xmlapi/base.py b/pa_api/xmlapi/base.py new file mode 100644 index 0000000..566798f --- /dev/null +++ b/pa_api/xmlapi/base.py @@ -0,0 +1,137 @@ +import logging +from typing import Union + +import requests + +from pa_api.constants import SUCCESS_CODE + +from .utils import Element, detach, etree_fromstring, etree_tostring + + +def get_tree( + host, api_key, remove_blank_text=True, verify=False, timeout=None, logger=None +): + """ + This function returns the whole configuration of Panorama/the firewall + as an XML object + + remove_blank_text: + the response might contain extra white-spaces that will mess up + the display. This option allows to automatically remove the extra white-spaces + verify: Force the validation of https certificate + """ + if logger is None: + logger = logging + res = requests.get( + f"{host}/api?type=config&action=show&xpath=/config", + headers={"X-PAN-KEY": api_key}, + verify=verify, + timeout=timeout, + ) + root_tree = etree_fromstring(res.content, remove_blank_text=remove_blank_text) + try: + tree = root_tree.xpath("/response/result/config")[0] + except Exception: + logger.warning("Response doesn't contains the config tag. Response:") + logger.warning(etree_tostring(root_tree, pretty_print=True).decode()[:1000]) + raise Exception("Response doesn't contains the config tag. Check the logs") + detach(tree) # Remove the /response/result part + return tree + + +def parse_msg_result(result: Element) -> str: + """ + Parse the `msg` tag from Panorama response. + This function always return the message as a single string + """ + # Get the content from the default location + msg = "".join(result.xpath("./msg/text()")) + # Check another possible location + if not msg: + msg = "".join(result.xpath("./result/msg/text()")) + if msg: + return msg + # Last possibility: + # The message might be split in elements inside of msg + return "\n".join(result.xpath("./msg/line/text()")) + + +def _get_rule_use_cmd(device_group, position, rule_type, start_index, number) -> str: + """ + This function return the `cmd` parameter to filter the data for rule usage. + NOTE: These values are paged, we need to provide an offset and a limit. + + device_group: the device group that contains the rules and their usage data + position: when the rule is used. Can be "pre" or "post" + rule_type: One of the rule-type ("security", "pbf", "nat", "application-override") + start_index: start index of the records to retrieve (aka "offset") + number: number of records to retrieve (aka "limit") + """ + # positions = ("pre", "post") + return f""" + get-all + (rule-state eq 'any') + {device_group} + {position} + {rule_type} + {start_index} + {number} + rule_usage + """ + + +def raw_request( + url, + type, + method="GET", + vsys=None, + params=None, + headers=None, + remove_blank_text=True, + verify=False, + logger=None, + parse=True, + stream=None, + timeout=None, +) -> Union[str, Element]: + """ + This function is a wrapper around requests.method. + It returns: + - XML in case of success + - a string with the message if a message is expected + + It does the heavy lifting when receiving a response from Panorama: + - Data clean up + - Conversion to XML + - Status check and automaticly raise exception in case of error. + """ + if logger is None: + logger = logging + query_params = {"type": type} + if params: + query_params = {**query_params, **params} + if vsys is not None: + query_params["vsys"] = vsys + + res = requests.request( + method=method, + url=url, + params=query_params, + headers=headers, + verify=verify, + stream=stream, + timeout=timeout, + ) + if not parse: + return res + content = res.content.decode() + tree = etree_fromstring(content, remove_blank_text=remove_blank_text) + status = tree.attrib["status"] + code = int(tree.get("code", SUCCESS_CODE)) + msg = parse_msg_result(tree) + if status == "error" or code < SUCCESS_CODE: + logger.debug(content[:500]) + raise Exception(msg) + if msg: + return msg + return tree diff --git a/pa_api/xmlapi/client.py b/pa_api/xmlapi/client.py new file mode 100644 index 0000000..b8ad1bb --- /dev/null +++ b/pa_api/xmlapi/client.py @@ -0,0 +1,1124 @@ +import logging +from itertools import chain, product +from multiprocessing.pool import ThreadPool as Pool +from typing import List, Optional, Tuple, Union + +from pa_api.utils import clean_url_host, first, get_credentials_from_env + +from . import types +from .base import _get_rule_use_cmd, get_tree, raw_request +from .utils import ( + Element, + el2dict, + extend_element, + map_dicts, + wait, +) + + +class XMLApi: + def __init__( + self, + host=None, + api_key=None, + ispanorama=None, + verify=False, + timeout=None, + logger=None, + ): + env_host, env_apikey = get_credentials_from_env() + host = host or env_host + api_key = api_key or env_apikey + if not host: + raise Exception("Missing Host") + if not api_key: + raise Exception("Missing API Key") + host, _, _ = clean_url_host(host) + + self._host = host + self._api_key = api_key + self._url = f"{host}/api" + self._verify = verify + self._timeout = timeout + self._ispanorama = ispanorama + self.logger = logger or logging + + def _request( + self, + type, + method="GET", + vsys=None, + params=None, + remove_blank_text=True, + verify=None, + parse=True, + stream=None, + timeout=None, + ): + if verify is None: + verify = self._verify + if timeout is None: + timeout = self._timeout + headers = {"X-PAN-KEY": self._api_key} + return raw_request( + self._url, + type, + method, + vsys=vsys, + params=params, + headers=headers, + remove_blank_text=remove_blank_text, + verify=verify, + logger=self.logger, + parse=parse, + stream=stream, + timeout=timeout, + ) + + # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/export-files-api + # https://knowledgebase.paloaltonetworks.com/KCSArticleDetail?id=kA10g000000ClaOCAS#:~:text=From%20the%20GUI%2C%20go%20to%20Device%20%3E%20Setup,%3E%20scp%20export%20configuration%20%5Btab%20for%20command%20help%5D + def _export_request( + self, + category, + method="GET", + params=None, + verify=None, + stream=None, + timeout=None, + ): + if params is None: + params = {} + params = {"category": category, **params} + return self._request( + "export", + method=method, + params=params, + verify=verify, + parse=False, + stream=stream, + timeout=timeout, + ).content + + def export_configuration( + self, + verify=None, + timeout=None, + ) -> Element: + return self._export_request( + category="configuration", + verify=verify, + timeout=timeout, + ) + + def export_device_state( + self, + verify=None, + timeout=None, + ) -> Element: + return self._export_request( + category="device-state", + verify=verify, + timeout=timeout, + ) + + def _conf_request( + self, + xpath, + action="get", + method="GET", + vsys=None, + params=None, + remove_blank_text=True, + verify=None, + timeout=None, + ) -> Element: + if params is None: + params = {} + params = {"action": action, "xpath": xpath, **params} + return self._request( + "config", + method=method, + vsys=vsys, + params=params, + remove_blank_text=remove_blank_text, + verify=verify, + timeout=timeout, + ) + + def _op_request( + self, + cmd, + method="POST", + vsys=None, + params=None, + remove_blank_text=True, + verify=None, + timeout=None, + ) -> Element: + if params is None: + params = {} + params = {"cmd": cmd, **params} + return self._request( + "op", + method=method, + vsys=vsys, + params=params, + remove_blank_text=remove_blank_text, + verify=verify, + timeout=timeout, + ) + + def _commit_request( + self, + cmd, + method="POST", + params=None, + remove_blank_text=True, + verify=None, + timeout=None, + ): + if params is None: + params = {} + params = {"cmd": cmd, **params} + return self._request( + "commit", + method=method, + params=params, + remove_blank_text=remove_blank_text, + verify=verify, + timeout=timeout, + ) + + # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-xml-api/get-your-api-key + def generate_apikey(self, username, password: str) -> str: + """ + Generate a new API-Key for the user connected. + """ + params = {"user": username, "password": password} + return self._request( + "keygen", + method="POST", + params=params, + ).xpath(".//key/text()")[0] + + # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/get-version-info-api + def api_version(self): + return el2dict( + self._request( + "version", + method="POST", + ).xpath(".//result")[0] + )["result"] + + def configuration( + self, + xpath, + action="get", + method="GET", + params=None, + remove_blank_text=True, + ): + return self._conf_request( + xpath, + action=action, + method=method, + params=params, + remove_blank_text=remove_blank_text, + ) + + def operation( + self, + cmd, + method="POST", + params=None, + remove_blank_text=True, + ): + return self._op_request( + cmd, + method=method, + params=params, + remove_blank_text=remove_blank_text, + ) + + def _check_is_panorama(self) -> bool: + try: + self.configuration("/config/panorama/vsys") + return False + except Exception: + return True + + @property + def ispanorama(self): + if self._ispanorama is None: + self._ispanorama = self._check_is_panorama() + return self._ispanorama + + def get_tree(self, extended=False) -> Element: + """ + Return the running configuration + The differences with `running_config` are not known + """ + tree = get_tree( + self._host, self._api_key, verify=self._verify, logger=self.logger + ) + if extended: + self._extend_tree_information(tree) + return tree + + def _get_rule_use(self, device_group, position, rule_type, number: int = 200): + results = [] + for i in range(100): + cmd = _get_rule_use_cmd( + device_group, + position, + rule_type, + i * number, + number, + ) + res = self._op_request(cmd).xpath("result")[0] + total_count = int(res.attrib["total-count"]) + results.extend(res.xpath("entry")) + if len(results) >= total_count: + break + return results + + def get_rule_use(self, tree=None, max_threads: Optional[int] = None): + if tree is None: + tree = self.get_tree() + device_groups = tree.xpath("devices/*/device-group/*/@name") + positions = ("pre", "post") + # rule_types = tuple({x.tag for x in tree.xpath( + # "devices/*/device-group/*" + # "/*[self::post-rulebase or self::pre-rulebase]/*")}) + rule_types = ("security", "pbf", "nat", "application-override") + args_list = list(product(device_groups, positions, rule_types)) + + def func(args): + return self._get_rule_use(*args) + + threads = len(args_list) + threads = min(max_threads or threads, threads) + with Pool(len(args_list)) as pool: + data = pool.map(func, args_list) + return [entry for entry_list in data for entry in entry_list] + + def _get_rule_hit_count(self, device_group, rulebase, rule_type): + cmd = ( + "" + f"<{rulebase}>" + f"" + "" + ) + res = self._op_request(cmd) + entries = res.xpath(".//rules/entry") or [] + # return entries + return [(device_group, rulebase, rule_type, e) for e in entries] + + def get_rule_hit_count(self, tree=None, max_threads=None): + if tree is None: + tree = self.get_tree() + device_groups = tree.xpath("devices/*/device-group/*/@name") + rulebases = ("pre-rulebase", "post-rulebase") + rule_types = ("security", "pbf", "nat", "application-override") + args_list = list(product(device_groups, rulebases, rule_types)) + + def func(args): + return self._get_rule_hit_count(*args) + + threads = len(args_list) + threads = min(max_threads or threads, threads) + with Pool(len(args_list)) as pool: + data = pool.map(func, args_list) + return [entry for entry_list in data for entry in entry_list] + + def _extend_tree_information( + self, + tree, + extended=None, + max_threads=None, + ): + """ + Incorporate usage statistics into the configuration. + tree: the configuration as a XML object + extended: rule-use data (if not provided, the function will retrieve them automatically) + """ + if extended is None: + extended = self.get_rule_use(tree, max_threads=max_threads) + rules = tree.xpath( + ".//device-group/entry/" + "*[self::pre-rulebase or self::post-rulebase]/*/rules/entry[@uuid]", + ) + ext_dict = {x.attrib.get("uuid"): x for x in extended} + rules_dict = {x.attrib["uuid"]: x for x in rules} + for ext, rule in map_dicts(ext_dict, rules_dict): + extend_element(rule, ext) + # NOTE: Do not use rule.extend(ext) + # => This is causing duplicates entries + return tree, extended + + def get(self, xpath: str): + """ + This will retrieve the xml definition based on the xpath + The xpath doesn't need to be exact + and can select multiple values at once. + Still, it must at least speciy /config at is begining + """ + return self._conf_request(xpath, action="show", method="GET") + + def delete(self, xpath: str): + """ + This will REMOVE the xml definition at the provided xpath. + The xpath must be exact. + """ + return self._conf_request( + xpath, + action="delete", + method="DELETE", + ) + + def create(self, xpath: str, xml_definition): + """ + This will ADD the xml definition + INSIDE the element at the provided xpath. + The xpath must be exact. + """ + # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration + params = {"element": xml_definition} + return self._conf_request( + xpath, + action="set", + method="POST", + params=params, + ) + + def update(self, xpath: str, xml_definition): + """ + This will REPLACE the xml definition + INSTEAD of the element at the provided xpath + The xpath must be exact. + Nb: We can pull the whole config, update it locally, + and push the final result + """ + # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration + params = {"element": xml_definition} + return self._conf_request( + xpath, + action="edit", + method="POST", + params=params, + ) + + def revert_changes(self, skip_validated: bool = False): + """ + Revert all the changes made on Panorama. + NOTE: + - This only applies on non-commited changes. + - This revert everything (not scoped by users) + + skip_validated: Do not revert changes that were validated + """ + skip = "yes" if skip_validated else "" + cmd = f"{skip}" + return self._op_request(cmd) + + def validate_changes(self): + """ + Validated all the changes currently made + """ + cmd = "" + return self._op_request(cmd) + + def _raw_get_push_scope(self, admin=None): + """ + Gives detailed information about pending changes + (e.g. xpath, owner, action, ...) + """ + filter = f"{admin}" if admin else "" + cmd = f"{filter}" + return self._op_request(cmd) + + def get_push_scope_devicegroups(self, admin=None): + """ + Gives detailed information about pending changes + (e.g. xpath, owner, action, ...) + """ + scope = self._raw_get_push_scope(admin=admin) + return list(set(scope.xpath(".//objects/entry[@loc-type='device-group']/@loc"))) + + def uncommited_changes(self): + """ + Gives detailed information about pending changes + (e.g. xpath, owner, action, ...) + """ + cmd = "" + return self._op_request(cmd) + + def uncommited_changes_summary(self, admin=None): + """ + Only gives the concern device groups + """ + admin = ( + f"{admin}" + if admin + else "" + ) + cmd = f"{admin}" + return self._op_request(cmd) + + def pending_changes(self): + """ + Result content is either 'yes' or 'no' + """ + cmd = "" + return self._op_request(cmd) + + def save_config(self, name): + """ + Create a named snapshot of the current configuration + """ + cmd = f"{name}" + return "\n".join(self._op_request(cmd).xpath(".//result/text()")) + + def save_device_state(self): + """ + Create a snapshot of the current device state + """ + cmd = "" + return "\n".join(self._op_request(cmd).xpath(".//result/text()")) + + def get_named_configuration(self, name): + """ + Get the configuration from a named snapshot as an XML object + """ + cmd = f"{name}" + return self._op_request(cmd, remove_blank_text=False).xpath("./result/config")[ + 0 + ] + + def candidate_config(self) -> Element: + """ + Get the configuration to be commited as an XML object + """ + cmd = "" + return self._op_request(cmd, remove_blank_text=False) + + def running_config(self) -> Element: + """ + Get the current running configuration as an XML object + """ + cmd = "" + return self._op_request(cmd, remove_blank_text=False) + + def _raw_get_jobs(self, job_ids: Union[None, str, List[str]] = None) -> Element: + """ + Get information of job(s) as an XML object. + Retrieve all jobs by default. + + If job_id is provided, then only retrieve the job requested. + """ + filter = "" + if job_ids: + if isinstance(job_ids, str): + job_ids = [job_ids] + filter = "".join(f"{j}" for j in job_ids) + cmd = f"{filter}" + return self._op_request(cmd) + + def get_jobs(self, job_ids: Union[None, str, List[str]] = None) -> List[types.Job]: + """ + Get information of job(s) + Retrieve all jobs by default. + + If job_id is provided, then only retrieve the job requested. + """ + job_xmls = self._raw_get_jobs(job_ids).xpath(".//job") + transformed = (types.Job.from_xml(x) for x in job_xmls) + return [j for j in transformed if j] + + def get_job(self, job_id) -> types.Job: + """ + Get information of job(s) + Retrieve all jobs by default. + + If job_id is provided, then only retrieve the job requested. + """ + return self.get_jobs(job_id)[0] + + def _raw_get_versions(self) -> Element: + """ + Get the versions informations as a XML object. + """ + cmd = "" + return self.operation(cmd) + + def get_versions(self) -> List[types.SoftwareVersion]: + """ + Get the versions informations + """ + res = self._raw_get_versions() + return [ + types.SoftwareVersion.from_xml(entry) + for entry in res.xpath(".//sw-updates/versions/entry") + ] + + def wait_job_completion(self, job_id: str, waiter=None) -> types.Job: + """ + Block until the job complete. + + job_id: the job to wait upon + waiter: a generator that yield when a new query must be done. + see `wait` function (the default waiter) for an example + """ + if not waiter: + waiter = wait() + for _ in waiter: + job = self.get_job(job_id) + if job.progress >= 100: + return job + self.logger.info(f"Job {job_id} progress: {job.progress}") + raise Exception("Timeout while waiting for job completion") + + def raw_get_pending_jobs(self): + """ + Get all the jobs that are pending as a XML object + """ + cmd = "" + return self._op_request(cmd) + + def commit_changes(self, force: bool = False): + """ + Commit all changes + """ + cmd = "{}".format("" if force else "") + return self._commit_request(cmd) + + def _lock_cmd(self, cmd, vsys, no_exception=False) -> bool: + """ + Utility function for commands that tries to manipulate the lock + on Panorama. + """ + try: + result = "".join(self._op_request(cmd, vsys=vsys).itertext()) + self.logger.debug(result) + except Exception as e: + if no_exception: + self.logger.error(e) + return False + raise + return True + + # https://github.com/PaloAltoNetworks/pan-os-python/blob/a6b018e3864ff313fed36c3804394e2c92ca87b3/panos/base.py#L4459 + def add_config_lock(self, comment=None, vsys="shared", no_exception=False) -> bool: + comment = f"{comment}" if comment else "" + cmd = f"{comment}" + return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception) + + def remove_config_lock(self, vsys="shared", no_exception=False) -> bool: + cmd = "" + return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception) + + def add_commit_lock(self, comment=None, vsys="shared", no_exception=False) -> bool: + comment = f"{comment}" if comment else "" + cmd = f"{comment}" + return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception) + + def remove_commit_lock(self, vsys="shared", no_exception=False) -> bool: + cmd = "" + return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception) + + def set_ha_status(self, active: bool = True, target: Optional[str] = None): + """ + Activate or Deactivate (suspend) the HA pair. + + """ + status = "" if active else "" + cmd = f"{status}" + params = {"target": target} if target else None + return self._op_request(cmd, params=params).xpath(".//result/text()")[0] + + def set_ha_preemption(self, active=True, target=None): + """ + NOT WORKING: + There is currently no way to deactivate the preemption using the API. + """ + raise Exception("set_ha_preemption not implementend") + + def _raw_get_ha_info(self, state_only=False, target=None) -> Element: + """ + Get the current state of a HA pair as a XML object. + """ + filter = "" if state_only else "" + cmd = f"{filter}" + params = {"target": target} if target else None + return self._op_request(cmd, params=params) + + def get_ha_info(self, state_only=False, target=None) -> types.HAInfo: + """ + Get the current state of a HA pair as a python object. + """ + res = self._raw_get_ha_info(state_only=state_only, target=target) + hainfo_xml = res.xpath(".//result")[0] + # pprint(hainfo_xml) + return types.HAInfo.from_xml(hainfo_xml) + + def get_ha_pairs( + self, connected=True + ) -> Tuple[List[Tuple[types.Device, Optional[types.Device]]], List[types.Device]]: + """ + Retrieve a tuple containing 2 values: + 1. The list of HA pairs and their members + 2. A list of devices that are not part of a HA pair + """ + # Get all devices and index them using their serial number + devices: List[types.Device] = self.get_devices(connected=connected) + device_map = {d.serial: d for d in devices} + + # Create the 2 lists by iterating over the devices + done = set() + ha_pairs = [] + without_ha = [] + for d in devices: + # Do not manage twice the same device + if d.serial in done: + continue + # The device does not have an HA peer + if not d.ha_peer_serial: + without_ha.append(d) + done.add(d.serial) + continue + # Get the current device's HA peer + # push them in the ha_pairs list + # and mark both of them as done + peer = device_map.get(d.ha_peer_serial) + ha_pairs.append((d, peer)) + done.update((d.serial, d.ha_peer_serial)) + return ha_pairs, without_ha + + def get_ha_pairs_map(self, connected=True): + """ + Same as `get_ha_pairs`, but the ha_pairs are return as a map. + This provides an easier and more readable lookup to find a pair: + + mapping, _ = client.get_ha_pairs_map() + serial = "12345" + pair_of_serial = mapping[serial] + """ + ha_pairs, without_ha = self.get_ha_pairs(connected=connected) + map = {} + for pair in ha_pairs: + for device in pair: + map[device.serial] = pair + return map, without_ha + + def get_panorama_status(self): + """ + Get the current status of Panorama server. + """ + cmd = "" + return self.operation(cmd).xpath(".//result") + + def raw_get_local_panorama(self): + return self.configuration( + "/config/devices/entry/deviceconfig/system/panorama/local-panorama/panorama-server" + ) + + def get_local_panorama_ip(self) -> Optional[str]: + res = self.raw_get_local_panorama() + return first(res.xpath("//panorama-server/text()")) + + def _raw_get_devices(self, connected=False): + """ + Return the list of device known from Panorama as a XML object. + NOTE: This only works if the client is a Panorama server. + + connected: only returns the devices that are connected + """ + # This only works on Panorama, not the FW + filter = "" if connected else "" + cmd = f"{filter}" + return self.operation(cmd) + + def get_devices(self, connected=False) -> List[types.Device]: + """ + Return the list of device known from Panorama as a python structure. + NOTE: This only works if the client is a Panorama server. + + connected: only returns the devices that are connected + """ + res = self._raw_get_devices(connected=connected) + entries = res.xpath(".//devices/entry") + devices = (types.Device.from_xml(e) for e in entries) + return [d for d in devices if d] + + def _raw_get_dg_hierarchy(self): + """ + Return the hierarchy of device groups as a XML object. + """ + cmd = "" + return self.operation(cmd) + + def get_plan_dg_hierarchy(self, recursive=False): + """ + Return the hierarchy of device groups as a dict. + The keys are the names of the device groups. + + The values are the children device groups and depends on the recursive parameter. + recursive: if False, the values are only the direct children of the device group. + Otherwise, the values are all the descendant device groups. + """ + devicegroups = {} # name: children + hierarchy = self._raw_get_dg_hierarchy().xpath(".//dg-hierarchy")[0] + xpath = ".//dg" if recursive else "./dg" + for dg in hierarchy.xpath(".//dg"): + devicegroups[dg.attrib["name"]] = [ + x.attrib["name"] for x in dg.xpath(xpath) + ] + return devicegroups + + def _raw_get_devicegroups(self): + """ + Return the list of device groups as a XML object. + """ + cmd = "" + return self.operation(cmd) + + def get_devicegroups_name( + self, + parents=None, + with_connected_devices=None, + ): + """ + This returns the names of the devicegroups: + - parents: the returned list will only contain children of the provided parents (parents included) + - with_devices: the returned list will only contain devicegroups that have direct devices under them + """ + devicegroups = self._raw_get_devicegroups().xpath(".//devicegroups/entry") + if with_connected_devices: + names = [ + dg.attrib["name"] + for dg in devicegroups + if dg.xpath("./devices/entry/connected[text() = 'yes']") + ] + else: + names = [dg.attrib["name"] for dg in devicegroups] + if parents: + hierarchy = self.get_plan_dg_hierarchy(recursive=True) + tokeep = set(chain(*(hierarchy.get(p, []) for p in parents))) | set(parents) + names = list(set(names) & tokeep) + return names + + def _raw_get_addresses(self): + """ + Return the list of addresses known from Panorama as a XML object. + NOTE: This only works if the client is a Firewall. + """ + if self.ispanorama: + return self.configuration( + "/config/devices/entry/device-group/entry/address" + ) + return self.configuration("/config/panorama/vsys//address") + + def get_addresses(self) -> List[types.Address]: + """ + Return the list of addresses known from Panorama as a python structure. + NOTE: This only works if the client is a Firewall. + """ + res = self._raw_get_addresses() + addresses = res.xpath(".//address/entry") + return [types.Address.from_xml(i) for i in addresses] + + def _raw_get_routing_tables(self) -> Element: + """ + Return the list of interfaces known from Panorama as a XML object. + NOTE: This only works if the client is a Firewall. + """ + return self.configuration( + "/config/devices/entry/network/virtual-router/entry/routing-table" + ) + + def get_routing_tables(self) -> List[types.RoutingTable]: + """ + Return the list of interface known from Panorama as a python structure. + NOTE: This only works if the client is a Firewall. + """ + res = self._raw_get_routing_tables() + routing_tables = res.xpath(".//routing-table") + # print(len(routing_tables)) + # from pa_api.xmlapi.utils import pprint + # for r in routing_tables: + # pprint(r) + return [types.RoutingTable.from_xml(i) for i in routing_tables] + + def _raw_get_interfaces(self) -> Element: + """ + Return the list of interfaces known from Panorama as a XML object. + NOTE: This only works if the client is a Firewall. + """ + return self.configuration("/config/devices/entry/network/interface") + + def get_interfaces(self) -> List[types.Interface]: + """ + Return the list of interface known from Panorama as a python structure. + NOTE: This only works if the client is a Firewall. + """ + res = self._raw_get_interfaces() + interfaces = res.xpath(".//interface") + return [types.Interface.from_xml(i) for i in interfaces] + + def _raw_get_zones(self) -> Element: + """ + Return the list of zones known from Panorama as a XML object. + NOTE: This only works if the client is a Firewall. + """ + if self.ispanorama: + return self.configuration( + "/config/devices/entry/*/entry/config/devices/entry/vsys/entry/zone" + ) + return self.configuration("/config/devices/entry/vsys/entry/zone") + + def get_zones(self) -> Element: + """ + Return the list of zones known from Panorama as a python structure. + NOTE: This only works if the client is a Firewall. + """ + res = self._raw_get_zones() + zones = res.xpath(".//zone/entry") + return [types.Zone.from_xml(i) for i in zones] + + def _raw_get_templates(self, name=None) -> Element: + """ + Return the synchronization status the templates per devices as a XML object. + A device is in sync if it is up-to-date with the current version on Panorama. + NOTE: This only works on Panorama. + """ + # This only works on Panorama, not the FW + filter = f"{name}" if name else "" + cmd = f"{filter}" + return self.operation(cmd) + + def get_templates_sync_status(self): + """ + Return the synchronization status the templates per devices + A device is in sync if it is up-to-date with the current version on Panorama. + NOTE: This only works on Panorama. + + The result is a list of tuple of 3 values: + 1. the template's name + 2. the device's name + 3. the sync status + """ + res = self._raw_get_templates() + statuses = [] + for entry in res.xpath("./result/templates/entry"): + template_name = entry.attrib["name"] + for device in entry.xpath("./devices/entry"): + device_name = device.attrib["name"] + template_status = next(device.xpath("./template-status/text()"), None) + status = (template_name, device_name, template_status) + statuses.append(status) + return statuses + + def _raw_get_vpn_flows(self, name=None) -> List[Element]: + """ + Returns the VPN flow information as a XML object. + NOTE: This only works on Panorama server, not firewalls + """ + # This only works on Panorama, not the FW" + filter = f"{name}" if name else "" + cmd = f"{filter}" + return self.operation(cmd) + + def get_vpn_flows(self, name=None): + """ + Returns the VPN flow information as a python structure. + NOTE: This only works on Panorama server, not firewalls + """ + entries = self._raw_get_vpn_flows(name=name).xpath(".//IPSec/entry") + return [types.VPNFlow.from_xml(e) for e in entries] + + def system_info(self): + """ + Returns informations about the system as a XML object. + """ + cmd = "" + return self.operation(cmd) + + def _raw_system_resources(self): + """ + Get the system resouces as a XML object. + NOTE: The string is the raw output of a `ps` command. + """ + cmd = "" + return self.operation(cmd) + + def system_resources(self): + """ + Get the system resouces as a string. + The string is the raw output of a `ps` command. + """ + res = self._raw_system_resources() + text = res.xpath(".//result/text()")[0] + return text.split("\n\n")[0] + + def _raw_download_software(self, version): + """ + Download the software version on the device. + version: the software version to download + """ + cmd = f"{version}" + return self.operation(cmd) + + def download_software(self, version) -> Optional[str]: + """ + Download the software version on the device. + version: the software version to download + + Returns the download job's ID in case of successful launch, + None is returned otherwise. + """ + res = self._raw_download_software(version) + try: + return res.xpath(".//job/text()")[0] + except Exception: + self.logger.debug("Download has not started") + return None + + def _raw_install_software(self, version): + """ + Install the software version on the device. + version: the software version to install + """ + cmd = f"{version}" + return self.operation(cmd) + + def install_software( + self, version: Union[None, str, types.SoftwareVersion] + ) -> Optional[str]: + """ + Install the software version on the device. + version: the software version to install + + Returns the download job's ID in case of successful launch, + None is returned otherwise. + """ + if isinstance(version, types.SoftwareVersion): + version = version.version + res = self._raw_install_software(version) + try: + return res.xpath(".//job/text()")[0] + except Exception: + self.logger.debug("Download has not started") + return None + + def _raw_restart(self): + """ + Restart the device + """ + cmd = "" + return self.operation(cmd) + + def restart(self): + """ + Restart the device + """ + return "".join(self._raw_restart().xpath(".//result/text()")) + + def automatic_download_software( + self, version: Optional[str] = None + ) -> types.SoftwareVersion: + """ + Automatically download the requested software version. + if the version is not provided, it defaults to the latest one. + + NOTE: This does not do the installation. + This is usefull to download in anticipation of the upgrade. + For automatic install, see `automatic_software_upgrade` + """ + version_str = version + versions = self.get_versions() + sw_version = None + if not version_str: + sw_version = next((v for v in versions if v.latest), None) + else: + sw_version = next((v for v in versions if v.version == version_str), None) + if not sw_version: + self.logger.error(f"Version {version_str} not found") + return exit(1) + + # Already downloaded: Nothing to do + if sw_version.downloaded: + self.logger.info(f"Version {sw_version.version} already downloaded") + return sw_version + + # Download minor version first (required) + base_version = next( + v for v in versions if v.version == sw_version.base_minor_version + ) + if not base_version.downloaded: + self.logger.info( + f"Launching download of minor version {base_version.version}" + ) + job_id = self.download_software(base_version.version) + if not job_id: + raise Exception("Download has not started") + job = self.wait_job_completion(job_id) + if job.result != "OK": + self.logger.debug(job) + raise Exception(job.details) + print(job.details) + + # Actually download the wanted version + self.logger.info(f"Launching download of version {sw_version.version}") + job_id = self.download_software(sw_version.version) + if not job_id: + raise Exception("Download has not started") + job = self.wait_job_completion(job_id) + if job.result != "OK": + self.logger.debug(job) + raise Exception(job.details) + self.logger.info(job.details) + return sw_version + + def automatic_software_upgrade( + self, version: Optional[str] = None, install: bool = True, restart: bool = True + ): + """ + Automatically download and install the requested software version. + if the version is not provided, it defaults to the latest one. + + NOTE: This does the software install and restart by default. + If you only want to download, prefer to use `automatic_download_software` method, + or set install=False. See the parameters for more information. + + install: install the software after the download + restart: restart the device after the installation. This option is ignored if install=False + + """ + sw_version = self.automatic_download_software(version) + if sw_version.current: + self.logger.info(f"Version {sw_version.version} is already installed") + return sw_version + if not install: + return sw_version + # We may get the following error: + # "Error: Upgrading from 10.2.4-h10 to 11.1.2 requires a content version of 8761 or greater and found 8638-7689." + # This should never happen, we decided to report the error and handle this manually + self.logger.info(f"Launching install of version {sw_version.version}") + + job_id = self.install_software(sw_version.version) + if not job_id: + self.logger.error("Install has not started") + raise Exception("Install has not started") + job = self.wait_job_completion(job_id) + self.logger.info(job.details) + + # Do not restart if install failed + if job.result != "OK": + self.logger.error("Failed to install software version") + return sw_version + + if restart: + self.logger.info("Restarting the device") + restart_response = self.restart() + self.logger.info(restart_response) + return sw_version diff --git a/pa_api/xmlapi/constants.py b/pa_api/xmlapi/constants.py new file mode 100644 index 0000000..3cdeb4e --- /dev/null +++ b/pa_api/xmlapi/constants.py @@ -0,0 +1,3 @@ +PATH_SEARCH_PREFIX = "./devices/entry/device-group" +CONFIG_XPATH = "/config/devices/entry/device-group" +PATH_NAME_PREFIX = "/config/devices/entry/device-group/entry" diff --git a/pa_api/xmlapi/objects.py b/pa_api/xmlapi/objects.py new file mode 100644 index 0000000..543de56 --- /dev/null +++ b/pa_api/xmlapi/objects.py @@ -0,0 +1,35 @@ +from ipaddress import IPv4Network, IPv6Network +from typing import List, Union + +from pydantic import AliasChoices, BaseModel, ConfigDict, Field + +IPNetwork = Union[IPv4Network, IPv6Network] + + +class Address(BaseModel): + model_config = ConfigDict(extra="allow") + + device_group: str + name: str = Field(validation_alias=AliasChoices("@name", "name")) + prefix: str + ip_netmask: str + ip_network: IPNetwork + ip_range: str + fqdn: str + tags: List[str] + + # name: str = Field(validation_alias=AliasChoices("@name", "name")) + # device_group: str = Field(alias="device-group") + # rulebase: Literal["pre-rulebase", "post-rulebase"] = Field(alias="rulebase") + # ttype: str = Field(alias="type") + # state: Optional[str] = Field(alias="rule-state") + # modification: datetime = Field(alias="rule-modification-timestamp") + # creation: datetime = Field(alias="rule-creation-timestamp") + # all_connected: bool = Field(alias="all-connected") + + # @field_validator("modification", "creation", mode="before") + # @classmethod + # def ensure_datetime(cls, v: Any): + # if not isinstance(v, int): + # v = int(v) + # return datetime.fromtimestamp(v) diff --git a/pa_api/xmlapi/types/__init__.py b/pa_api/xmlapi/types/__init__.py new file mode 100644 index 0000000..e734931 --- /dev/null +++ b/pa_api/xmlapi/types/__init__.py @@ -0,0 +1,28 @@ +from pa_api.utils import ( + first, +) + +from .config import ( + Address, + AggregateEthernet, + DeviceGroup, + Ethernet, + GenericInterface, + Interface, + Layer2, + Layer3, + Loopback, + RoutingTable, + RuleBase, + Security, + Vlan, + Zone, +) +from .operations import ( + Device, + HAInfo, + Job, + JobResult, + SoftwareVersion, + VPNFlow, +) diff --git a/pa_api/xmlapi/types/config/__init__.py b/pa_api/xmlapi/types/config/__init__.py new file mode 100644 index 0000000..14ce269 --- /dev/null +++ b/pa_api/xmlapi/types/config/__init__.py @@ -0,0 +1,15 @@ +from .address import Address +from .devicegroup import DeviceGroup +from .interface import ( + AggregateEthernet, + Ethernet, + GenericInterface, + Interface, + Layer2, + Layer3, + Loopback, + Vlan, +) +from .routing import RoutingTable +from .rules import NAT, RuleBase, Security +from .zone import Zone diff --git a/pa_api/xmlapi/types/config/address.py b/pa_api/xmlapi/types/config/address.py new file mode 100644 index 0000000..0d73c60 --- /dev/null +++ b/pa_api/xmlapi/types/config/address.py @@ -0,0 +1,92 @@ +# Given a list of subnets, +# Find all NAT rules related to an address in the subnet + +from ipaddress import IPv4Network, IPv6Network, ip_network +from typing import Optional, Union + +from pydantic import AliasChoices, AliasPath, Field +from pydantic.functional_validators import field_validator, model_validator +from typing_extensions import Self + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + +IPNetwork = Union[IPv4Network, IPv6Network] + + +def get_ip_network(ip_netmask): + try: + if ip_netmask: + return ip_network(ip_netmask, strict=False) + except Exception: + return None + + +# https://docs.pydantic.dev/latest/concepts/alias/#aliaspath-and-aliaschoices +class Address(XMLBaseModel): + name: str = Field(validation_alias="@name") + type: Optional[str] = None + prefix: Optional[str] = None + ip_netmask: Optional[str] = Field( + alias="ip-netmask", + validation_alias=AliasChoices( + AliasPath("ip-netmask", "#text"), + "ip-netmask", + ), + default=None, + ) + ip_network: Optional[IPNetwork] = None + ip_range: Optional[str] = Field(alias="ip-range", default=None) + fqdn: Optional[String] = None + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), default=None + ) + + @field_validator("tags", mode="before") + @classmethod + def validate_tags(cls, v) -> List[str]: + if not v: + return [] + if not isinstance(v, list): + return [v] + return v + + @model_validator(mode="after") + def validate_ip_network(self) -> Self: + if self.ip_network is None: + self.ip_network = get_ip_network(self.ip_netmask) + if not isinstance(self.ip_network, (IPv4Network, IPv6Network)): + self.ip_network = None + return self + + @model_validator(mode="after") + def validate_type(self) -> Self: + address_type = None + if self.prefix: + address_type = "prefix" + elif self.ip_netmask: + address_type = "ip-netmask" + elif self.ip_range: + address_type = "ip-range" + elif self.fqdn: + address_type = "fqdn" + self.type = address_type + return self + + +def find_addresses(tree): + # addresses_xml = tree.xpath(".//address/entry") + addresses_xml = tree.xpath("./devices/entry/device-group//address/entry") + address_objects = [Address.from_xml(n) for n in addresses_xml] + + addresses = [] + subnets = [] + for a in address_objects: + network = a.ip_network + # We do not consider ip ranges for now + if not network: + continue + if network.prefixlen == network.max_prefixlen: + addresses.append(a) + else: + subnets.append(a) + return addresses, subnets diff --git a/pa_api/xmlapi/types/config/devicegroup.py b/pa_api/xmlapi/types/config/devicegroup.py new file mode 100644 index 0000000..03ab025 --- /dev/null +++ b/pa_api/xmlapi/types/config/devicegroup.py @@ -0,0 +1,46 @@ +from typing import Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + +from .address import Address +from .rules import RuleBase + + +class DeviceGroup(XMLBaseModel): + """ + This is used to parse the output of the running configuration. + """ + + model_config = ConfigDict(extra="allow") + + name: String = Field(validation_alias="@name") + description: String = "" + + devices: List[String] = Field( + validation_alias=AliasPath("devices", "entry", "@name"), default_factory=list + ) + # devices: List[Device] = Field( + # validation_alias=AliasPath("devices", "entry"), default_factory=list + # ) + addresses: List[Address] = Field( + validation_alias=AliasPath("address", "entry"), default_factory=list + ) + post_rulebase: Optional[RuleBase] = Field( + validation_alias="post-rulebase", default=None + ) + pre_rulebase: Optional[RuleBase] = Field( + validation_alias="pre-rulebase", default=None + ) + # applications: List[Application] = Field( + # validation_alias=AliasPath("application", "entry"), default_factory=list + # ) + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), default_factory=list + ) + + def iter_rulebases(self): + for rulebase in (self.pre_rulebase, self.post_rulebase): + if rulebase is not None: + yield rulebase diff --git a/pa_api/xmlapi/types/config/interface.py b/pa_api/xmlapi/types/config/interface.py new file mode 100644 index 0000000..d2542ed --- /dev/null +++ b/pa_api/xmlapi/types/config/interface.py @@ -0,0 +1,373 @@ +from ipaddress import ip_network +from typing import ClassVar, Iterable, Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import Ip, List, String, XMLBaseModel + + +def get_ip_network(ip_netmask): + try: + if ip_netmask: + return ip_network(ip_netmask, strict=False) + except Exception: + return None + + +class GenericInterface(XMLBaseModel): + model_config = ConfigDict(extra="ignore") + inttype: str + parent: Optional[str] = None + name: str + description: String = "" + comment: String = "" + ip: List[str] = Field(default_factory=list) + untagged_sub_interface: Optional[String] = None + tags: List[String] = Field(default_factory=list) + link_state: Optional[str] = None + link_speed: Optional[str] = None + link_duplex: Optional[str] = None + aggregate_group: Optional[String] = None + + +class Layer2(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "layer2" + + name: String = Field(validation_alias="@name", default="") + units: List["Layer2"] = Field( + alias="units", + validation_alias=AliasPath("units", "entry"), + default_factory=list, + ) + comment: String = "" + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + if self.name: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + parent = self.name + for u in self.units: + yield from u.flatten(parent) + + +class Layer3(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "layer3" + + name: Optional[String] = Field(validation_alias="@name", default=None) + description: String = Field(validation_alias="#text", default="") + ip: List[Ip] = Field( + validation_alias=AliasPath("ip", "entry"), default_factory=list + ) + untagged_sub_interface: Optional[String] = Field( + alias="untagged-sub-interface", + default=None, + ) + units: List["Layer3"] = Field( + alias="units", + validation_alias=AliasPath("units", "entry"), + default_factory=list, + ) + comment: String = "" + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + if self.name: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + parent = self.name + for u in self.units: + yield from u.flatten(parent) + + +class Vlan(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "vlan" + + name: Optional[String] = Field(validation_alias="@name", default=None) + description: String = Field(validation_alias="#text", default="") + ip: List[Ip] = Field( + validation_alias=AliasPath("ip", "entry"), default_factory=list + ) + # untagged_sub_interface: Optional[String] = Field( + # alias="untagged-sub-interface", + # default=None, + # ) + units: List["Vlan"] = Field( + alias="units", + validation_alias=AliasPath("units", "entry"), + default_factory=list, + ) + comment: String = "" + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + if self.name: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + parent = self.name + for u in self.units: + yield from u.flatten(parent) + + +class Ethernet(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "ethernet" + + name: str = Field(validation_alias="@name") + ip: List[str] = Field( + validation_alias=AliasPath("layer3", "ip", "entry", "@name"), + default_factory=list, + ) + description: String = Field(validation_alias="#text", default="") + link_state: Optional[str] = Field( + alias="link-state", + validation_alias=AliasPath("link-state", "#text"), + default=None, + ) + link_speed: Optional[str] = Field( + alias="link-speed", + validation_alias=AliasPath("link-speed", "#text"), + default=None, + ) + link_duplex: Optional[str] = Field( + alias="link-duplex", + validation_alias=AliasPath("link-duplex", "#text"), + default=None, + ) + aggregate_group: Optional[String] = Field( + alias="aggregate-group", + default=None, + ) + layer2: Optional[Layer2] = Field(alias="layer2", default=None) + layer3: Optional[Layer3] = Field(alias="layer3", default=None) + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + if self.name: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + parent = self.name + if self.layer2: + yield from self.layer2.flatten(parent) + if self.layer3: + yield from self.layer3.flatten(parent) + + # @model_validator(mode="before") + # @classmethod + # def test(cls, data): + # print("\n" * 5) + # print("Ethernet:", data) + # return data + + +class AggregateEthernet(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "aggregate" + + name: str = Field(validation_alias="@name") + ip: List[str] = Field( + validation_alias=AliasPath("layer3", "ip", "entry", "@name"), + default_factory=list, + ) + description: String = Field(validation_alias="#text", default="") + comment: String = "" + units: List["AggregateEthernet"] = Field( + alias="units", + validation_alias=AliasPath("units", "entry"), + default_factory=list, + ) + layer2: Optional[Layer2] = Field(alias="layer2", default=None) + layer3: Optional[Layer3] = Field(alias="layer3", default=None) + untagged_sub_interface: Optional[String] = Field( + alias="untagged-sub-interface", + default=None, + ) + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + # @model_validator(mode="before") + # @classmethod + # def test(cls, data): + # print("\n" * 5) + # print("AggregateEthernet:", data) + # return data + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + if self.name: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + parent = self.name + if self.layer2: + yield from self.layer2.flatten(parent) + if self.layer3: + yield from self.layer3.flatten(parent) + + +class Tunnel(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "tunnel" + + name: str = Field(validation_alias="@name") + units: List["Tunnel"] = Field( + alias="units", + validation_alias=AliasPath("units", "entry"), + default_factory=list, + ) + ip: List[str] = Field( + validation_alias=AliasPath("ip", "entry", "@name"), + default_factory=list, + ) + interface_management_profile: Optional[String] = Field( + validation_alias="interface-management-profile", default=None + ) + + comment: Optional[str] = Field( + alias="comment", validation_alias=AliasPath("comment", "#text"), default=None + ) + mtu: Optional[str] = Field( + alias="comment", validation_alias=AliasPath("mtu", "#text"), default=None + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + + +class Loopback(XMLBaseModel): + model_config = ConfigDict(extra="allow") + inttype: ClassVar[str] = "loopback" + + name: str = Field(validation_alias="@name") + description: Optional[String] = Field(validation_alias="#text", default=None) + ip: List[Ip] = Field( + validation_alias=AliasPath("ip", "entry"), default_factory=list + ) + comment: Optional[str] = Field( + alias="comment", validation_alias=AliasPath("comment", "#text"), default=None + ) + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), + default_factory=list, + ) + + def flatten(self, parent=None) -> Iterable[GenericInterface]: + dump = self.model_dump() + dump.update( + { + "inttype": self.inttype, + "parent": parent, + } + ) + generic = GenericInterface.model_validate(dump) + yield generic + + +# https://docs.pydantic.dev/latest/concepts/alias/#aliaspath-and-aliaschoices +class Interface(XMLBaseModel): + model_config = ConfigDict(extra="allow") + + aggregate_ethernet: List[AggregateEthernet] = Field( + alias="aggregate-ethernet", + validation_alias=AliasPath("aggregate-ethernet", "entry"), + default_factory=list, + ) + # entry = Field(alias="entry") + ethernet: List[Ethernet] = Field( + alias="ethernet", + validation_alias=AliasPath("ethernet", "entry"), + default_factory=list, + ) + loopback: List[Loopback] = Field( + alias="loopback", + validation_alias=AliasPath("loopback", "units", "entry"), + default_factory=list, + ) + vlan: List[Vlan] = Field( + alias="vlan", + validation_alias=AliasPath("vlan", "units", "entry"), + default_factory=list, + ) + tunnel: List[Tunnel] = Field( + alias="tunnel", + validation_alias=AliasPath("tunnel", "units", "entry"), + default_factory=list, + ) + + # ha1 = Field(alias='ha1') + # ha1_backup = Field(alias='ha1-backup') + # ha2 = Field(alias='ha2') + # ha2_backup = Field(alias='ha2-backup') + # ha3 = Field(alias='ha3') + # member = Field(alias='member') + # tunnel = Field(alias='tunnel') + + def _flatten(self) -> Iterable[GenericInterface]: + for eth in self.ethernet: + yield from eth.flatten() + for agg in self.aggregate_ethernet: + yield from agg.flatten() + for v in self.vlan: + yield from v.flatten() + for lb in self.loopback: + yield from lb.flatten() + + def flatten(self) -> List[GenericInterface]: + return list(self._flatten()) diff --git a/pa_api/xmlapi/types/config/routing/__init__.py b/pa_api/xmlapi/types/config/routing/__init__.py new file mode 100644 index 0000000..815d9b1 --- /dev/null +++ b/pa_api/xmlapi/types/config/routing/__init__.py @@ -0,0 +1,2 @@ +from . import routing_table +from .routing_table import RoutingTable diff --git a/pa_api/xmlapi/types/config/routing/routing_table.py b/pa_api/xmlapi/types/config/routing/routing_table.py new file mode 100644 index 0000000..03dabc6 --- /dev/null +++ b/pa_api/xmlapi/types/config/routing/routing_table.py @@ -0,0 +1,34 @@ +from typing import Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + + +class NextHop(XMLBaseModel): + model_config = ConfigDict(extra="ignore") + + ip_address: Optional[String] = Field(validation_alias="ip-address", default=None) + + +class StaticRoute(XMLBaseModel): + model_config = ConfigDict(extra="ignore") + + name: String = Field(validation_alias="@name") + nexthop: Optional[NextHop] = Field(validation_alias="nexthop", default=None) + interface: Optional[String] = Field(validation_alias="interface", default=None) + destination: String = Field(validation_alias="destination") + + +class IPv4RoutingTable(XMLBaseModel): + model_config = ConfigDict(extra="ignore") + + static_routes: List[StaticRoute] = Field( + validation_alias=AliasPath("static-route", "entry") + ) + + +class RoutingTable(XMLBaseModel): + model_config = ConfigDict(extra="ignore") + + ip: IPv4RoutingTable = Field(validation_alias="ip") diff --git a/pa_api/xmlapi/types/config/rules/__init__.py b/pa_api/xmlapi/types/config/rules/__init__.py new file mode 100644 index 0000000..f2c883a --- /dev/null +++ b/pa_api/xmlapi/types/config/rules/__init__.py @@ -0,0 +1,4 @@ +from . import nat, rulebase, security +from .nat import NAT +from .rulebase import RuleBase +from .security import Security diff --git a/pa_api/xmlapi/types/config/rules/nat.py b/pa_api/xmlapi/types/config/rules/nat.py new file mode 100644 index 0000000..ec663d2 --- /dev/null +++ b/pa_api/xmlapi/types/config/rules/nat.py @@ -0,0 +1,135 @@ +import typing +from itertools import chain +from typing import Optional, Union + +from pydantic import AliasPath, Field + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + + +class DynamicIPAndPort(XMLBaseModel): + translated_address: List[String] = Field( + validation_alias="translated-address", default=None + ) + ip: Optional[String] = Field( + validation_alias=AliasPath("interface-address", "ip"), default=None + ) + interface: Optional[String] = Field( + validation_alias=AliasPath("interface-address", "interface"), default=None + ) + + +class DynamicIP(XMLBaseModel): + translated_address: List[String] = Field( + validation_alias="translated-address", default=None + ) + + +class StaticIP(XMLBaseModel): + translated_address: String = Field(validation_alias="translated-address") + + +class SourceTranslation(XMLBaseModel): + dynamic_ip_and_port: Optional[DynamicIPAndPort] = Field( + validation_alias="dynamic-ip-and-port", default=None + ) + dynamic_ip: Optional[DynamicIP] = Field(validation_alias="dynamic-ip", default=None) + static_ip: Optional[StaticIP] = Field(validation_alias="static-ip", default=None) + + @property + def translation(self) -> Union[DynamicIPAndPort, DynamicIP, StaticIP]: + for trans in (self.dynamic_ip_and_port, self.dynamic_ip, self.static_ip): + if trans is not None: + return trans + raise Exception("Invalid sourc translation") + + @property + def translated_address(self) -> typing.List[str]: + trans = self.translation.translated_address + if isinstance(trans, str): + return [trans] + return trans + + @property + def type(self) -> str: + if self.static_ip is not None: + return "static-ip" + if self.dynamic_ip is not None: + return "dynamic-ip" + if self.dynamic_ip_and_port is not None: + return "dynamic-ip-and-port" + raise Exception("Invalid sourc translation") + + +class DestinationTranslation(XMLBaseModel): + translated_address: Optional[String] = Field( + validation_alias=AliasPath("translated-address", "#text"), default=None + ) + translated_port: Optional[int] = Field( + validation_alias=AliasPath("translated-port", "#text"), default=None + ) + + +class NAT(XMLBaseModel): + name: String = Field(validation_alias="@name") + uuid: String = Field(validation_alias="@uuid") + disabled: Optional[bool] = None + description: String = "" + group_tag: Optional[String] = Field(validation_alias="group-tag", default=None) + tags: List[String] = Field( + validation_alias="tag", + default_factory=list, + ) + services: List[String] = Field(validation_alias="service", default_factory=list) + + source_translation: Optional[SourceTranslation] = Field( + validation_alias="source-translation", default=None + ) + destination_translation: Optional[DestinationTranslation] = Field( + validation_alias="destination-translation", default=None + ) + + sources: List[String] = Field( + validation_alias="source", + default_factory=list, + ) + destinations: List[String] = Field( + validation_alias="destination", + default_factory=list, + ) + to: List[String] = Field( + validation_alias="to", + default_factory=list, + ) + from_: List[String] = Field( + validation_alias="from", + default_factory=list, + ) + + @property + def translated_src_address(self) -> typing.List[str]: + if not self.source_translation: + return [] + return self.source_translation.translated_address + + @property + def translated_dst_address(self) -> typing.List[str]: + if not self.destination_translation: + return [] + translated = self.destination_translation.translated_address + if not translated: + return [] + return [translated] + + @property + def members(self): + return set( + chain( + self.to, + self.from_, + self.sources, + self.destination_translation, + self.translated_src_address, + self.translated_dst_address, + ) + ) diff --git a/pa_api/xmlapi/types/config/rules/rulebase.py b/pa_api/xmlapi/types/config/rules/rulebase.py new file mode 100644 index 0000000..d235996 --- /dev/null +++ b/pa_api/xmlapi/types/config/rules/rulebase.py @@ -0,0 +1,19 @@ +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import List, XMLBaseModel + +from .nat import NAT +from .security import Security + + +class RuleBase(XMLBaseModel): + model_config = ConfigDict(extra="allow") + + security: List[Security] = Field( + validation_alias=AliasPath("security", "rules", "entry"), + default_factory=list, + ) + nat: List[NAT] = Field( + validation_alias=AliasPath("nat", "rules", "entry"), + default_factory=list, + ) diff --git a/pa_api/xmlapi/types/config/rules/security.py b/pa_api/xmlapi/types/config/rules/security.py new file mode 100644 index 0000000..58d948e --- /dev/null +++ b/pa_api/xmlapi/types/config/rules/security.py @@ -0,0 +1,82 @@ +from typing import Literal, Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + + +class ProfileSetting(XMLBaseModel): + groups: List[String] = Field( + validation_alias=AliasPath("group", "member"), default_factory=list + ) + + +class Option(XMLBaseModel): + disable_server_response_inspection: Optional[bool] = Field( + validation_alias="disable-server-response-inspection", default=None + ) + + +class Target(XMLBaseModel): + negate: Optional[bool] = None + + +class Security(XMLBaseModel): + model_config = ConfigDict(extra="allow") + + name: String = Field(validation_alias="@name") + uuid: String = Field(validation_alias="@uuid") + disabled: Optional[bool] = None + + action: Literal["allow", "deny", "reset-client"] + + to: List[String] = Field( + validation_alias=AliasPath("to", "member"), default_factory=list + ) + from_: List[String] = Field( + validation_alias=AliasPath("from", "member"), default_factory=list + ) + sources: List[String] = Field( + validation_alias=AliasPath("source", "member"), default_factory=list + ) + destinations: List[String] = Field( + validation_alias=AliasPath("destination", "member"), default_factory=list + ) + source_users: List[String] = Field( + validation_alias=AliasPath("source-user", "member"), default_factory=list + ) + services: List[String] = Field( + validation_alias=AliasPath("service", "member"), default_factory=list + ) + applications: List[String] = Field( + validation_alias=AliasPath("application", "member"), default_factory=list + ) + + description: String = "" + categories: List[String] = Field( + validation_alias=AliasPath("category", "member"), default_factory=list + ) + tags: List[String] = Field( + validation_alias=AliasPath("tag", "member"), default_factory=list + ) + group_tag: Optional[String] = Field(validation_alias="group-tag", default=None) + + profile_settings: List[ProfileSetting] = Field( + validation_alias=AliasPath("profile-settings"), default_factory=list + ) + target: Optional[Target] = Field(validation_alias=AliasPath("target"), default=None) + + option: Optional[Option] = Field(default=None) + rule_type: Optional[str] = Field(validation_alias="rule-type", default=None) + negate_source: Optional[bool] = Field( + validation_alias="negate-source", default=None + ) + negate_destination: Optional[bool] = Field( + validation_alias="negate-destination", default=None + ) + log_settings: Optional[str] = Field(validation_alias="log-settings", default=None) + log_start: Optional[bool] = Field(validation_alias="log-start", default=None) + log_end: Optional[bool] = Field(validation_alias="log-end", default=None) + icmp_unreachable: Optional[bool] = Field( + validation_alias="icmp-unreachable", default=None + ) diff --git a/pa_api/xmlapi/types/config/zone.py b/pa_api/xmlapi/types/config/zone.py new file mode 100644 index 0000000..8095a4f --- /dev/null +++ b/pa_api/xmlapi/types/config/zone.py @@ -0,0 +1,33 @@ +from typing import Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.xmlapi.types.utils import List, String, XMLBaseModel + + +class ZoneNetwork(XMLBaseModel): + model_config = ConfigDict(extra="allow") + + name: String = Field(validation_alias="@name", default="") + layer3: List[String] = Field( + validation_alias=AliasPath("layer3", "member"), + default_factory=list, + ) + enable_packet_buffer_protection: Optional[bool] = Field( + validation_alias=AliasPath("enable-packet-buffer-protection", "#text"), + default=None, + ) + + +class Zone(XMLBaseModel): + model_config = ConfigDict(extra="allow") + + name: String = Field(validation_alias="@name", default="") + network: Optional[ZoneNetwork] = None + enable_user_identification: Optional[bool] = Field( + validation_alias=AliasPath("enable-user-identification", "#text"), default=None + ) + enable_device_identification: Optional[bool] = Field( + validation_alias=AliasPath("enable-device-identification", "#text"), + default=None, + ) diff --git a/pa_api/xmlapi/types/operations/__init__.py b/pa_api/xmlapi/types/operations/__init__.py new file mode 100644 index 0000000..6555c87 --- /dev/null +++ b/pa_api/xmlapi/types/operations/__init__.py @@ -0,0 +1,4 @@ +from . import device, job, software +from .device import Device, HAInfo, VPNFlow +from .job import Job, JobResult +from .software import SoftwareVersion diff --git a/pa_api/xmlapi/types/operations/device.py b/pa_api/xmlapi/types/operations/device.py new file mode 100644 index 0000000..195e669 --- /dev/null +++ b/pa_api/xmlapi/types/operations/device.py @@ -0,0 +1,174 @@ +from typing import Optional + +from pydantic import AliasPath, ConfigDict, Field + +from pa_api.utils import ( + first, +) +from pa_api.xmlapi.types.utils import ( + Datetime, + XMLBaseModel, + mksx, +) + + +class Device(XMLBaseModel): + model_config = ConfigDict(populate_by_name=True, extra="allow") + + serial: str + connected: bool + unsupported_version: bool = Field(validation_alias="unsupported-version") + wildfire_rt: bool = Field(validation_alias="wildfire-rt") + deactivated: Optional[str] = None + hostname: Optional[str] = None + ip_address: Optional[str] = Field(validation_alias="ip-address", default=None) + ipv6_address: Optional[str] = Field(validation_alias="ipv6-address", default=None) + mac_addr: Optional[str] = Field(validation_alias="mac-addr", default=None) + uptime: Optional[str] = None + family: Optional[str] = None + model: Optional[str] = None + sw_version: Optional[str] = Field(validation_alias="sw-version", default=None) + app_version: Optional[str] = Field(validation_alias="app-version", default=None) + av_version: Optional[str] = Field(validation_alias="av-version", default=None) + device_dictionary_version: Optional[str] = Field( + validation_alias="device-dictionary-version", default="" + ) + wildfire_version: Optional[str] = Field( + validation_alias="wildfire-version", default=None + ) + threat_version: Optional[str] = Field( + validation_alias="threat-version", default=None + ) + url_db: Optional[str] = Field(validation_alias="url-db", default=None) + url_filtering_version: Optional[str] = Field( + validation_alias="url-filtering-version", default=None + ) + logdb_version: Optional[str] = Field(validation_alias="logdb-version", default=None) + vpnclient_package_version: Optional[str] = Field( + validation_alias="vpnclient-package-version", default=None + ) + global_protect_client_package_version: Optional[str] = Field( + validation_alias="global-protect-client-package-version", default=None + ) + prev_app_version: Optional[str] = Field( + validation_alias="prev-app-version", default=None + ) + prev_av_version: Optional[str] = Field( + validation_alias="prev-av-version", default=None + ) + prev_threat_version: Optional[str] = Field( + validation_alias="prev-threat-version", default=None + ) + prev_wildfire_version: Optional[str] = Field( + validation_alias="prev-wildfire-version", default=None + ) + prev_device_dictionary_version: Optional[str] = Field( + validation_alias="prev-device-dictionary-version", default="" + ) + # domain/: str + # slot_count: str + # type/: str + # tag/: str + # plugin_versions + # ha_cluster + ha_peer_serial: Optional[str] = Field( + validation_alias=AliasPath("ha", "peer", "serial", "#text"), default=None + ) + vpn_disable_mode: bool = Field(validation_alias="vpn-disable-mode") + operational_mode: str = Field(validation_alias="operational-mode") + certificate_status: Optional[str] = Field( + validation_alias="certificate-status", default=None + ) + certificate_subject_name: Optional[str] = Field( + validation_alias="certificate-subject-name", default=None + ) + certificate_expiry: Optional[Datetime] = Field( + validation_alias="certificate-expiry", default=None + ) + connected_at: Optional[Datetime] = Field( + validation_alias="connected-at", default=None + ) + custom_certificate_usage: Optional[str] = Field( + validation_alias="custom-certificate-usage", default=None + ) + multi_vsys: bool = Field(validation_alias="multi-vsys") + # vsys + last_masterkey_push_status: str = Field( + validation_alias="last-masterkey-push-status" + ) + last_masterkey_push_timestamp: Optional[str] = Field( + validation_alias="last-masterkey-push-timestamp", default=None + ) + express_mode: bool = Field(validation_alias="express-mode") + device_cert_present: Optional[str] = Field( + validation_alias="device-cert-present", default=None + ) + device_cert_expiry_date: str = Field(validation_alias="device-cert-expiry-date") + + +class VPNFlow(XMLBaseModel): + model_config = ConfigDict(populate_by_name=True, extra="allow") + + name: str + id: int + gwid: int + inner_if: str = Field(validation_alias="inner-if") + outer_if: str = Field(validation_alias="outer-if") + localip: str + peerip: str + state: str + mon: str + owner: str + + +class HAInfo(XMLBaseModel): + model_config = ConfigDict(populate_by_name=True, extra="allow") + + enabled: bool + preemptive: Optional[bool] = None + mode: Optional[str] = None + state: Optional[str] = None + peer_state: Optional[str] = None + priority: Optional[int] = None + peer_priority: Optional[int] = None + is_primary: Optional[bool] = None + peer_conn_status: Optional[str] = None + mgmt_ip: Optional[str] = None + ha1_ipaddr: Optional[str] = None + ha1_backup_ipaddr: Optional[str] = None + ha2_ipaddr: Optional[str] = None + ha1_macaddress: Optional[str] = None + ha1_backup_macaddress: Optional[str] = None + ha2_macaddress: Optional[str] = None + + @classmethod + def from_xml(cls, xml): + # TODO: Use correct pydantic functionalities + if isinstance(xml, (list, tuple)): + xml = first(xml) + if xml is None: + return None + p = mksx(xml) + priority = p("./group/local-info/priority/text()", parser=int) + peer_priority = p("./group/peer-info/priority/text()", parser=int) + is_primary = None + if priority is not None and peer_priority is not None: + is_primary = priority < peer_priority + return HAInfo( + enabled=p("./enabled/text()"), + preemptive=p("./group/local-info/preemptive/text()"), + mode=p("./group/local-info/mode/text()"), + state=p("./group/local-info/state/text()"), + peer_state=p("./group/peer-info/state/text()"), + priority=priority, + peer_priority=peer_priority, + is_primary=is_primary, + peer_conn_status=p("./group/peer-info/conn-status/text()"), + mgmt_ip=p("./group/local-info/mgmt-ip/text()"), + ha1_ipaddr=p("./group/local-info/ha1-ipaddr/text()"), + ha1_backup_ipaddr=p("./group/local-info/ha1-backup-ipaddr/text()"), + ha2_ipaddr=p("./group/local-info/ha2-ipaddr/text()"), + ha1_macaddress=p("./group/local-info/ha1-macaddr/text()"), + ha1_backup_macaddress=p("./group/local-info/ha1-backup-macaddr/text()"), + ha2_macaddress=p("./group/local-info/ha2-macaddr/text()"), + ) diff --git a/pa_api/xmlapi/types/operations/job.py b/pa_api/xmlapi/types/operations/job.py new file mode 100644 index 0000000..110bb35 --- /dev/null +++ b/pa_api/xmlapi/types/operations/job.py @@ -0,0 +1,88 @@ +import enum +import logging +from dataclasses import dataclass +from datetime import datetime, time +from typing import Optional + +from pa_api.utils import ( + first, +) +from pa_api.xmlapi.types.utils import ( + mksx, + parse_datetime, + parse_time, + pd, +) + + +def parse_tdeq(d): + if "null" in d: + return None + try: + return parse_time(d) + except Exception as e: + logging.debug(e) + return parse_datetime(d) + + +def parse_progress(progress): + try: + return float(progress) + except Exception as e: + logging.debug(f"{e} => Fallback to datetime parsing") + + # When finished, progress becomes the date of the end + if parse_datetime(progress): + return 100.0 + return None + + +class JobResult(enum.Enum): + OK = "OK" + FAIL = "FAIL" + + +@dataclass +class Job: + # TODO: Use pydantic + tenq: datetime + tdeq: time + id: str + user: str + type: str + status: str + queued: bool + stoppable: bool + result: str + tfin: datetime + description: str + position_in_queue: int + progress: float + details: str + warnings: str + + @staticmethod + def from_xml(xml) -> Optional["Job"]: + # TODO: Use correct pydantic functionalities + if isinstance(xml, (list, tuple)): + xml = first(xml) + if xml is None: + return None + p = mksx(xml) + return Job( + p("./tenq/text()", parser=pd), + p("./tdeq/text()", parser=parse_tdeq), + p("./id/text()"), + p("./user/text()"), + p("./type/text()"), + p("./status/text()"), + p("./queued/text()") != "NO", + p("./stoppable/text()") != "NO", + p("./result/text()"), + p("./tfin/text()", parser=pd), + p("./description/text()"), + p("./positionInQ/text()", parser=int), + p("./progress/text()", parser=parse_progress), + "\n".join(xml.xpath("./details/line/text()")), + p("./warnings/text()"), + ) diff --git a/pa_api/xmlapi/types/operations/software.py b/pa_api/xmlapi/types/operations/software.py new file mode 100644 index 0000000..74135b6 --- /dev/null +++ b/pa_api/xmlapi/types/operations/software.py @@ -0,0 +1,50 @@ +from dataclasses import dataclass +from datetime import datetime + +from pa_api.utils import ( + first, +) +from pa_api.xmlapi.types.utils import ( + mksx, + pd, +) + + +@dataclass +class SoftwareVersion: + # TODO: Use pydantic + version: str + filename: str + released_on: datetime + downloaded: bool + current: bool + latest: bool + uploaded: bool + + @staticmethod + def from_xml(xml): + # TODO: Use correct pydantic functionalities + if isinstance(xml, (list, tuple)): + xml = first(xml) + if xml is None: + return None + p = mksx(xml) + return SoftwareVersion( + p("./version/text()"), + p("./filename/text()"), + p("./released-on/text()", parser=pd), + p("./downloaded/text()") != "no", + p("./current/text()") != "no", + p("./latest/text()") != "no", + p("./uploaded/text()") != "no", + ) + + @property + def base_minor_version(self) -> str: + major, minor, _ = self.version.split(".") + return f"{major}.{minor}.0" + + @property + def base_major_version(self) -> str: + major, _, _ = self.version.split(".") + return f"{major}.0.0" diff --git a/pa_api/xmlapi/types/statistics.py b/pa_api/xmlapi/types/statistics.py new file mode 100644 index 0000000..a96bc50 --- /dev/null +++ b/pa_api/xmlapi/types/statistics.py @@ -0,0 +1,106 @@ +from datetime import datetime +from typing import Any, List, Literal, Optional, Union + +from pydantic import AliasChoices, BaseModel, ConfigDict, Field, field_validator + +from pa_api.xmlapi.utils import el2dict as xml2dict + + +class RuleHit(BaseModel): + name: str = Field(validation_alias=AliasChoices("@name", "name")) + device_group: str = Field(alias="device-group") + rulebase: Literal["pre-rulebase", "post-rulebase"] = Field(alias="rulebase") + type: str = Field(alias="type") + state: Optional[str] = Field(alias="rule-state") + modification: datetime = Field(alias="rule-modification-timestamp") + creation: datetime = Field(alias="rule-creation-timestamp") + all_connected: bool = Field(alias="all-connected") + + @field_validator("modification", "creation", mode="before") + @classmethod + def ensure_datetime(cls, v: Any): + if not isinstance(v, int): + v = int(v) + return datetime.fromtimestamp(v) + + @staticmethod + def from_tuple(t): + device_group, rulebase, rule_type, xml = t + return RuleHit.model_validate( + { + "device-group": device_group, + "rulebase": rulebase, + "type": rule_type, + **xml2dict(xml)["entry"], + } + ) + + +class RuleUse(BaseModel): + model_config = ConfigDict(extra="allow") + name: str = Field(validation_alias=AliasChoices("@name", "name")) + description: Optional[str] = Field(default=None) + uuid: str = Field(validation_alias=AliasChoices("@uuid", "uuid")) + state: Optional[str] = Field(alias="rule-state") + bytes: Optional[int] = Field(default=None) + group_tag: Optional[str] = Field(alias="group-tag", default=None) + tag: Optional[List[str]] = Field(default=None) + disabled: Optional[bool] = Field(default=None) + rule_type: Optional[Literal["interzone", "universal"]] = Field( + alias="rule-type", default=None + ) + nat_type: Optional[Literal["ipv4", "ipv6"]] = Field(alias="nat-type", default=None) + modification: datetime = Field(alias="rule-modification-timestamp") + creation: datetime = Field(alias="rule-creation-timestamp") + + action: Optional[Union[Literal["allow", "deny", "reset-client"], dict]] = Field( + default=None + ) + to_interface: str = Field(alias="to-interface", default=None) + protocol: Optional[Literal["tcp", "udp"]] = Field(default=None) + port: Optional[str] = Field(default=None) # Can be a port range + + to_: Optional[List[str]] = Field(alias="from", default=None) + from_: Optional[List[str]] = Field(alias="to", default=None) + source: Optional[List[str]] = Field(default=None) + destination: Optional[List[str]] = Field(default=None) + source_translation: Optional[List[str]] = Field( + alias="source-translation", default=None + ) + destination_translation: Optional[List[str]] = Field( + alias="destination-translation", default=None + ) + + source_user: Optional[List[str]] = Field(alias="source-user", default=None) + application: Optional[List[str]] = Field(default=None) + category: Optional[List[str]] = Field(default=None) + service: Optional[List[str]] = Field(default=None) + + icmp_unreachable: Optional[bool] = Field(alias="icmp-unreachable", default=None) + log_start: Optional[bool] = Field(alias="log-start", default=None) + log_end: Optional[bool] = Field(alias="log-end", default=None) + negate_source: Optional[bool] = Field(alias="negate-source", default=None) + negate_destination: Optional[bool] = Field(alias="negate-destination", default=None) + + @field_validator( + "tag", + "to_", + "from_", + "source", + "destination", + "source_translation", + "destination_translation", + "source_user", + "application", + "category", + "service", + mode="before", + ) + @classmethod + def ensure_membership(cls, v: Any): + if v is None: + return None + members = v.get("member") if isinstance(v, dict) else v + if isinstance(members, str): + members = [members] + return members diff --git a/pa_api/xmlapi/types/utils.py b/pa_api/xmlapi/types/utils.py new file mode 100644 index 0000000..cfe1924 --- /dev/null +++ b/pa_api/xmlapi/types/utils.py @@ -0,0 +1,233 @@ +import json +import logging +import typing +from datetime import datetime +from types import new_class +from typing import Annotated, Any, Optional, TypeVar + +from pydantic import BaseModel, TypeAdapter +from pydantic.functional_validators import ( + BeforeValidator, + PlainValidator, +) +from typing_extensions import Self, TypedDict + +from pa_api.utils import first +from pa_api.xmlapi.utils import el2dict + +DATETIME_FORMAT = "%Y/%m/%d %H:%M:%S" +TIME_FORMAT = "%H:%M:%S" +NoneType: type = type(None) + + +class XMLBaseModel(BaseModel): + @classmethod + def from_xml(cls, xml) -> Self: + rulebase = first(el2dict(xml).values()) + return cls.model_validate(rulebase) + + +def parse_datetime(d): + try: + if d is None or d == "none": + return None + return datetime.strptime(d, DATETIME_FORMAT) + except Exception as e: + logging.debug(e) + logging.debug(f"Failed to parse {d} as datetime") + print(d, type(d)) + raise + return d + + +def parse_time(d): + return datetime.strptime(d, TIME_FORMAT).time() + + +# https://docs.pydantic.dev/latest/concepts/types/#custom-types +# JobProgress = TypeAliasType('JobProgress', PlainValidator(parse_progress)) +# Datetime = TypeAliasType( +# "Datetime", Annotated[datetime, PlainValidator(parse_datetime)] +# ) +Datetime = Annotated[datetime, PlainValidator(parse_datetime)] + + +def single_xpath(xml, xpath, parser=None, default=None): + try: + res = xml.xpath(xpath) + res = first(res, None) + except Exception: + return default + if res is None: + return default + if not isinstance(res, str): + res = res.text + if parser: + res = parser(res) + return res + + +pd = parse_datetime +sx = single_xpath + + +def mksx(xml): + def single_xpath(xpath, parser=None, default=None): + res = sx(xml, xpath, parser=parser, default=default) + logging.debug(res) + return res + + return single_xpath + + +def ensure_list(v: Any) -> typing.List[Any]: + if v is None: + return [] + if isinstance(v, dict) and len(v) == 1 and "member" in v: + return ensure_list(v["member"]) + if isinstance(v, list): + return v + return [v] + + +# https://docs.pydantic.dev/latest/concepts/types/#generics +Element = TypeVar("Element", bound=Any) +# Similar to typing.List, but ensure to always return a list +List = Annotated[typing.List[Element], BeforeValidator(ensure_list)] + +# from pydantic import TypeAdapter +# ta = TypeAdapter(List[int]) +# print(ta.validate_python(5)) +# print(ta.validate_python([5])) +# print(ta.validate_python()) + + +def ensure_str(v: Any) -> str: + if v is None: + return "" + if isinstance(v, dict): + return v["#text"] + return v + + +def validate_ip(v: Any) -> str: + if v is None: + return "" + if isinstance(v, dict): + return v["@name"] + return v + + +String = Annotated[str, BeforeValidator(ensure_str)] +Ip = Annotated[str, BeforeValidator(validate_ip)] + + +def _xml2schema(values: list): + types: typing.List[Any] = [ + t.__name__ for t in {type(v) for v in values if not isinstance(v, (dict, list))} + ] + list_values = [v for v in values if isinstance(v, list)] + if list_values: + types.append(_xml2schema([e for sublist in list_values for e in sublist])) + dict_values = [v for v in values if isinstance(v, dict)] + if dict_values: + all_keys = {k for d in dict_values for k in d} + dict_schema = { + k: _xml2schema([d.get(k) for d in dict_values]) for k in all_keys + } + types.append(dict_schema) + if not types: + raise Exception("NO TYPE") + if len(types) == 1: + return types[0] + return types + + +def _clean_key(k): + return k.replace("@", "").replace("#", "") + + +def _slug(k): + return _clean_key(k).replace("-", "_") + + +def _keyastypename(k): + return "".join(p.title() for p in _clean_key(k).split("-")) + + +def _schematype(values: list, name: Optional[str] = None) -> type: + if not name: + name = "Dict" + optional = None in values + values = [v for v in values if v is not None] + schema_types: typing.List[Any] = list( + {type(v) for v in values if not isinstance(v, (dict, list))} + ) + list_values = [v for v in values if isinstance(v, list)] + if list_values: + t = _schematype([e for sublist in list_values for e in sublist], name=name) + schema_types.append(t) + dict_values = [v for v in values if isinstance(v, dict)] + if dict_values: + all_keys = {k for d in dict_values for k in d} + annotations = { + _slug(k): _schematype( + [d.get(k) for d in dict_values], name=_keyastypename(k) + ) + for k in all_keys + } + t = new_class( + name, + (TypedDict,), + None, + lambda ns: ns.update({"__annotations__": annotations}), + ) + schema_types.append(t) + if not schema_types: + return NoneType + # raise Exception("NO TYPE") + + final_type = ( + schema_types[0] if len(schema_types) == 1 else typing.Union[tuple(schema_types)] + ) + if optional: + final_type = Optional[final_type] + return final_type + + +def xml2schema(xml): + """ + Similar to schematype function: + The result is a recursive schema that can be dumped with json. + """ + data = el2dict(xml) + return _xml2schema([data]) + + +def schematype(data, name: Optional[str] = None): + """ + Recursively parse the data to infer the schema. + The schema is returned as a type. + + We can dump the json schema using pydantic: + TypeAdapter(schematype({"test": 5})).json_schema() + """ + return _schematype([data], name=name) + + +def xml2schematype(xml): + """ + Same to schematype function but takes an xml Element as parameter + """ + name, data = first(el2dict(xml).items()) + return schematype(data, name) + + +def jsonschema(data, name=None, indent=4) -> str: + ta = TypeAdapter(schematype(data, name)) + return json.dumps(ta.json_schema(), indent=indent) + + +def xml2jsonschema(data, indent=4) -> str: + ta = TypeAdapter(xml2schematype(data)) + return json.dumps(ta.json_schema(), indent=indent) diff --git a/pa_api/xmlapi/utils.py b/pa_api/xmlapi/utils.py new file mode 100644 index 0000000..b9a2ac8 --- /dev/null +++ b/pa_api/xmlapi/utils.py @@ -0,0 +1,148 @@ +# import defusedxml.lxml +# Safe XML parsing with custom options (solution of the author) +# https://github.com/tiran/defusedxml/issues/102 +# Nb: From issue #33, defusedxml.lxml should be depracted by the author. +# PARSER = etree.Parser(remove_blank_text=True, resolve_entities=False) +# LOOKUP = etree.ElementDefaultClassLookup(defusedxml.lxml.RestrictedElement) +# PARSER.set_element_class_lookup(LOOKUP) +# https://stackoverflow.com/questions/3310614/remove-whitespaces-in-xml-string +import time +from typing import List, Union + +import xmltodict +from lxml import etree # nosec B410 +from typing_extensions import TypeAlias + +# Element = NewType("Element", etree._Element) +_Element: TypeAlias = etree._Element # noqa: SLF001 +Element: TypeAlias = etree.Element + + +def _pprint(n: Element): + print(etree_tostring(n, True).decode()) + + +def pprint(n: Union[Element, List[Element]]): + if isinstance(n, list): + root = Element("pprint") + root.extend(e.copy() for e in n) + n = root + _pprint(n) + + +def wait_attempts(attempts: int = 100, pool_delay: int = 20, start_index: int = 0): + for i in range(start_index, start_index + attempts): + yield i + time.sleep(pool_delay) + return + + +def wait_with_duration(duration: int = 1800, pool_delay: int = 20): + start = time.perf_counter() + while True: + delta = time.perf_counter() - start + yield delta + if delta >= duration: + return + time.sleep(pool_delay) + + +wait = wait_with_duration + + +def etree_fromstring( + string: Union[str, bytes], remove_blank_text: bool = True +) -> Element: + parser = etree.XMLParser(remove_blank_text=remove_blank_text) + return etree.XML(string, parser=parser) + + +def etree_tostring(element: Element, pretty_print: bool = False) -> bytes: + return etree.tostring(element, pretty_print=pretty_print) + + +def parse_response(response: Union[str, bytes, Element]) -> List[Element]: + if isinstance(response, (str, bytes)): + # Nb: We should use defusedxml library but it doesn't support + # Removing blank spaces + response = etree_fromstring(response) + data = response.xpath("/response/result/*") + for d in data: + detach(d) + return data + + +def detach(e: Element) -> Element: + parent = e.getparent() + if parent is not None: + parent.remove(e) + return e + + +def delete_policy_membership(element): + entry = element.entry + # TODO: Check type + element.remove() # Remove element from tree + print(element.dumps(True)) + with entry.as_dict() as d: + d.target.negate = "no" + d["destination-hip"].member = "any" + print(element.dumps(True)) + + # client.update(e.xpath, e.dumps()) + # client.create(e.xpath, e.dumps()) + + +def map_dicts(a: dict, b: dict): + """ + Combine values from b with the value in a having the same key. + """ + for uuid, u in a.items(): + r = b.get(uuid) + if r is None: + continue + yield u, r + + +def extend_element(dest, elements): + """ + Only add element that are not already in the destination + element.extend(...) is causing duplicates entries because + the merge is not controlled + """ + children = {c.tag for c in dest.getchildren()} + for e in elements: + if e.tag in children: + continue + dest.append(e) + return dest + + +def el2dict(e: Union[str, Element]) -> dict: + if isinstance(e, str): + e = etree_fromstring(e) + e.tail = None + return xmltodict.parse(etree_tostring(e)) + + +# ============================================= +# Utility function to compare the changes between configurations +# Nb: native difflib is too slow + +# Using xmldiff.main.diff_trees gives false positives (can be filtered) and is very slow +# also, deepdiff.DeepDiff(el2dict(xml1), el2dict(xml2)).to_json() xpath is not able to use attributes to identify entries +# eval(re.findall(".*entry'\]\[\d+\]", diff["dictionary_item_added"][0])[0], {"root": y}) + + +# def _diff_patch(text1, text2): +# dmp = diff_match_patch() +# patches = dmp.patch_make(text1, text2) +# return urllib.parse.unquote(dmp.patch_toText(patches)) + + +# def diff_patch(xml1, xml2): +# if not isinstance(xml1, str): +# xml1 = etree_tostring(xml1).decode() +# if not isinstance(xml2, str): +# xml2 = etree_tostring(xml2).decode() +# return _diff_patch(xml1, xml2) diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..7a43b4d --- /dev/null +++ b/poetry.lock @@ -0,0 +1,506 @@ +# This file is automatically @generated by Poetry 1.8.3 and should not be changed by hand. + +[[package]] +name = "annotated-types" +version = "0.5.0" +description = "Reusable constraint types to use with typing.Annotated" +optional = false +python-versions = ">=3.7" +files = [ + {file = "annotated_types-0.5.0-py3-none-any.whl", hash = "sha256:58da39888f92c276ad970249761ebea80ba544b77acddaa1a4d6cf78287d45fd"}, + {file = "annotated_types-0.5.0.tar.gz", hash = "sha256:47cdc3490d9ac1506ce92c7aaa76c579dc3509ff11e098fc867e5130ab7be802"}, +] + +[package.dependencies] +typing-extensions = {version = ">=4.0.0", markers = "python_version < \"3.9\""} + +[[package]] +name = "certifi" +version = "2024.8.30" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.8.30-py3-none-any.whl", hash = "sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8"}, + {file = "certifi-2024.8.30.tar.gz", hash = "sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "idna" +version = "3.8" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.6" +files = [ + {file = "idna-3.8-py3-none-any.whl", hash = "sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac"}, + {file = "idna-3.8.tar.gz", hash = "sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603"}, +] + +[[package]] +name = "importlib-metadata" +version = "6.7.0" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "importlib_metadata-6.7.0-py3-none-any.whl", hash = "sha256:cb52082e659e97afc5dac71e79de97d8681de3aa07ff18578330904a9d18e5b5"}, + {file = "importlib_metadata-6.7.0.tar.gz", hash = "sha256:1aaf550d4f73e5d6783e7acb77aec43d49da8017410afae93822cc9cca98c4d4"}, +] + +[package.dependencies] +typing-extensions = {version = ">=3.6.4", markers = "python_version < \"3.8\""} +zipp = ">=0.5" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] + +[[package]] +name = "lxml" +version = "4.9.4" +description = "Powerful and Pythonic XML processing library combining libxml2/libxslt with the ElementTree API." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, != 3.4.*" +files = [ + {file = "lxml-4.9.4-cp27-cp27m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e214025e23db238805a600f1f37bf9f9a15413c7bf5f9d6ae194f84980c78722"}, + {file = "lxml-4.9.4-cp27-cp27m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:ec53a09aee61d45e7dbe7e91252ff0491b6b5fee3d85b2d45b173d8ab453efc1"}, + {file = "lxml-4.9.4-cp27-cp27m-win32.whl", hash = "sha256:7d1d6c9e74c70ddf524e3c09d9dc0522aba9370708c2cb58680ea40174800013"}, + {file = "lxml-4.9.4-cp27-cp27m-win_amd64.whl", hash = "sha256:cb53669442895763e61df5c995f0e8361b61662f26c1b04ee82899c2789c8f69"}, + {file = "lxml-4.9.4-cp27-cp27mu-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:647bfe88b1997d7ae8d45dabc7c868d8cb0c8412a6e730a7651050b8c7289cf2"}, + {file = "lxml-4.9.4-cp27-cp27mu-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:4d973729ce04784906a19108054e1fd476bc85279a403ea1a72fdb051c76fa48"}, + {file = "lxml-4.9.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:056a17eaaf3da87a05523472ae84246f87ac2f29a53306466c22e60282e54ff8"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:aaa5c173a26960fe67daa69aa93d6d6a1cd714a6eb13802d4e4bd1d24a530644"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:647459b23594f370c1c01768edaa0ba0959afc39caeeb793b43158bb9bb6a663"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:bdd9abccd0927673cffe601d2c6cdad1c9321bf3437a2f507d6b037ef91ea307"}, + {file = "lxml-4.9.4-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:00e91573183ad273e242db5585b52670eddf92bacad095ce25c1e682da14ed91"}, + {file = "lxml-4.9.4-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:a602ed9bd2c7d85bd58592c28e101bd9ff9c718fbde06545a70945ffd5d11868"}, + {file = "lxml-4.9.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:de362ac8bc962408ad8fae28f3967ce1a262b5d63ab8cefb42662566737f1dc7"}, + {file = "lxml-4.9.4-cp310-cp310-win32.whl", hash = "sha256:33714fcf5af4ff7e70a49731a7cc8fd9ce910b9ac194f66eaa18c3cc0a4c02be"}, + {file = "lxml-4.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:d3caa09e613ece43ac292fbed513a4bce170681a447d25ffcbc1b647d45a39c5"}, + {file = "lxml-4.9.4-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:359a8b09d712df27849e0bcb62c6a3404e780b274b0b7e4c39a88826d1926c28"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:43498ea734ccdfb92e1886dfedaebeb81178a241d39a79d5351ba2b671bff2b2"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:4855161013dfb2b762e02b3f4d4a21cc7c6aec13c69e3bffbf5022b3e708dd97"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:c71b5b860c5215fdbaa56f715bc218e45a98477f816b46cfde4a84d25b13274e"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9a2b5915c333e4364367140443b59f09feae42184459b913f0f41b9fed55794a"}, + {file = "lxml-4.9.4-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:d82411dbf4d3127b6cde7da0f9373e37ad3a43e89ef374965465928f01c2b979"}, + {file = "lxml-4.9.4-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:273473d34462ae6e97c0f4e517bd1bf9588aa67a1d47d93f760a1282640e24ac"}, + {file = "lxml-4.9.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:389d2b2e543b27962990ab529ac6720c3dded588cc6d0f6557eec153305a3622"}, + {file = "lxml-4.9.4-cp311-cp311-win32.whl", hash = "sha256:8aecb5a7f6f7f8fe9cac0bcadd39efaca8bbf8d1bf242e9f175cbe4c925116c3"}, + {file = "lxml-4.9.4-cp311-cp311-win_amd64.whl", hash = "sha256:c7721a3ef41591341388bb2265395ce522aba52f969d33dacd822da8f018aff8"}, + {file = "lxml-4.9.4-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:dbcb2dc07308453db428a95a4d03259bd8caea97d7f0776842299f2d00c72fc8"}, + {file = "lxml-4.9.4-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:01bf1df1db327e748dcb152d17389cf6d0a8c5d533ef9bab781e9d5037619229"}, + {file = "lxml-4.9.4-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:e8f9f93a23634cfafbad6e46ad7d09e0f4a25a2400e4a64b1b7b7c0fbaa06d9d"}, + {file = "lxml-4.9.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3f3f00a9061605725df1816f5713d10cd94636347ed651abdbc75828df302b20"}, + {file = "lxml-4.9.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:953dd5481bd6252bd480d6ec431f61d7d87fdcbbb71b0d2bdcfc6ae00bb6fb10"}, + {file = "lxml-4.9.4-cp312-cp312-win32.whl", hash = "sha256:266f655d1baff9c47b52f529b5f6bec33f66042f65f7c56adde3fcf2ed62ae8b"}, + {file = "lxml-4.9.4-cp312-cp312-win_amd64.whl", hash = "sha256:f1faee2a831fe249e1bae9cbc68d3cd8a30f7e37851deee4d7962b17c410dd56"}, + {file = "lxml-4.9.4-cp35-cp35m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:23d891e5bdc12e2e506e7d225d6aa929e0a0368c9916c1fddefab88166e98b20"}, + {file = "lxml-4.9.4-cp35-cp35m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:e96a1788f24d03e8d61679f9881a883ecdf9c445a38f9ae3f3f193ab6c591c66"}, + {file = "lxml-4.9.4-cp36-cp36m-macosx_11_0_x86_64.whl", hash = "sha256:5557461f83bb7cc718bc9ee1f7156d50e31747e5b38d79cf40f79ab1447afd2d"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:fdb325b7fba1e2c40b9b1db407f85642e32404131c08480dd652110fc908561b"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d74d4a3c4b8f7a1f676cedf8e84bcc57705a6d7925e6daef7a1e54ae543a197"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:ac7674d1638df129d9cb4503d20ffc3922bd463c865ef3cb412f2c926108e9a4"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_28_x86_64.whl", hash = "sha256:ddd92e18b783aeb86ad2132d84a4b795fc5ec612e3545c1b687e7747e66e2b53"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2bd9ac6e44f2db368ef8986f3989a4cad3de4cd55dbdda536e253000c801bcc7"}, + {file = "lxml-4.9.4-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:bc354b1393dce46026ab13075f77b30e40b61b1a53e852e99d3cc5dd1af4bc85"}, + {file = "lxml-4.9.4-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:f836f39678cb47c9541f04d8ed4545719dc31ad850bf1832d6b4171e30d65d23"}, + {file = "lxml-4.9.4-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:9c131447768ed7bc05a02553d939e7f0e807e533441901dd504e217b76307745"}, + {file = "lxml-4.9.4-cp36-cp36m-win32.whl", hash = "sha256:bafa65e3acae612a7799ada439bd202403414ebe23f52e5b17f6ffc2eb98c2be"}, + {file = "lxml-4.9.4-cp36-cp36m-win_amd64.whl", hash = "sha256:6197c3f3c0b960ad033b9b7d611db11285bb461fc6b802c1dd50d04ad715c225"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:7b378847a09d6bd46047f5f3599cdc64fcb4cc5a5a2dd0a2af610361fbe77b16"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:1343df4e2e6e51182aad12162b23b0a4b3fd77f17527a78c53f0f23573663545"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:6dbdacf5752fbd78ccdb434698230c4f0f95df7dd956d5f205b5ed6911a1367c"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:506becdf2ecaebaf7f7995f776394fcc8bd8a78022772de66677c84fb02dd33d"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ca8e44b5ba3edb682ea4e6185b49661fc22b230cf811b9c13963c9f982d1d964"}, + {file = "lxml-4.9.4-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:9d9d5726474cbbef279fd709008f91a49c4f758bec9c062dfbba88eab00e3ff9"}, + {file = "lxml-4.9.4-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:bbdd69e20fe2943b51e2841fc1e6a3c1de460d630f65bde12452d8c97209464d"}, + {file = "lxml-4.9.4-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8671622256a0859f5089cbe0ce4693c2af407bc053dcc99aadff7f5310b4aa02"}, + {file = "lxml-4.9.4-cp37-cp37m-win32.whl", hash = "sha256:dd4fda67f5faaef4f9ee5383435048ee3e11ad996901225ad7615bc92245bc8e"}, + {file = "lxml-4.9.4-cp37-cp37m-win_amd64.whl", hash = "sha256:6bee9c2e501d835f91460b2c904bc359f8433e96799f5c2ff20feebd9bb1e590"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:1f10f250430a4caf84115b1e0f23f3615566ca2369d1962f82bef40dd99cd81a"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:3b505f2bbff50d261176e67be24e8909e54b5d9d08b12d4946344066d66b3e43"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:1449f9451cd53e0fd0a7ec2ff5ede4686add13ac7a7bfa6988ff6d75cff3ebe2"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:4ece9cca4cd1c8ba889bfa67eae7f21d0d1a2e715b4d5045395113361e8c533d"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:59bb5979f9941c61e907ee571732219fa4774d5a18f3fa5ff2df963f5dfaa6bc"}, + {file = "lxml-4.9.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:b1980dbcaad634fe78e710c8587383e6e3f61dbe146bcbfd13a9c8ab2d7b1192"}, + {file = "lxml-4.9.4-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9ae6c3363261021144121427b1552b29e7b59de9d6a75bf51e03bc072efb3c37"}, + {file = "lxml-4.9.4-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bcee502c649fa6351b44bb014b98c09cb00982a475a1912a9881ca28ab4f9cd9"}, + {file = "lxml-4.9.4-cp38-cp38-win32.whl", hash = "sha256:a8edae5253efa75c2fc79a90068fe540b197d1c7ab5803b800fccfe240eed33c"}, + {file = "lxml-4.9.4-cp38-cp38-win_amd64.whl", hash = "sha256:701847a7aaefef121c5c0d855b2affa5f9bd45196ef00266724a80e439220e46"}, + {file = "lxml-4.9.4-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:f610d980e3fccf4394ab3806de6065682982f3d27c12d4ce3ee46a8183d64a6a"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:aa9b5abd07f71b081a33115d9758ef6077924082055005808f68feccb27616bd"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:365005e8b0718ea6d64b374423e870648ab47c3a905356ab6e5a5ff03962b9a9"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:16b9ec51cc2feab009e800f2c6327338d6ee4e752c76e95a35c4465e80390ccd"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:a905affe76f1802edcac554e3ccf68188bea16546071d7583fb1b693f9cf756b"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fd814847901df6e8de13ce69b84c31fc9b3fb591224d6762d0b256d510cbf382"}, + {file = "lxml-4.9.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:91bbf398ac8bb7d65a5a52127407c05f75a18d7015a270fdd94bbcb04e65d573"}, + {file = "lxml-4.9.4-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f99768232f036b4776ce419d3244a04fe83784bce871b16d2c2e984c7fcea847"}, + {file = "lxml-4.9.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bb5bd6212eb0edfd1e8f254585290ea1dadc3687dd8fd5e2fd9a87c31915cdab"}, + {file = "lxml-4.9.4-cp39-cp39-win32.whl", hash = "sha256:88f7c383071981c74ec1998ba9b437659e4fd02a3c4a4d3efc16774eb108d0ec"}, + {file = "lxml-4.9.4-cp39-cp39-win_amd64.whl", hash = "sha256:936e8880cc00f839aa4173f94466a8406a96ddce814651075f95837316369899"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-macosx_11_0_x86_64.whl", hash = "sha256:f6c35b2f87c004270fa2e703b872fcc984d714d430b305145c39d53074e1ffe0"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:606d445feeb0856c2b424405236a01c71af7c97e5fe42fbc778634faef2b47e4"}, + {file = "lxml-4.9.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:a1bdcbebd4e13446a14de4dd1825f1e778e099f17f79718b4aeaf2403624b0f7"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:0a08c89b23117049ba171bf51d2f9c5f3abf507d65d016d6e0fa2f37e18c0fc5"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:232fd30903d3123be4c435fb5159938c6225ee8607b635a4d3fca847003134ba"}, + {file = "lxml-4.9.4-pp37-pypy37_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:231142459d32779b209aa4b4d460b175cadd604fed856f25c1571a9d78114771"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-macosx_11_0_x86_64.whl", hash = "sha256:520486f27f1d4ce9654154b4494cf9307b495527f3a2908ad4cb48e4f7ed7ef7"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:562778586949be7e0d7435fcb24aca4810913771f845d99145a6cee64d5b67ca"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:a9e7c6d89c77bb2770c9491d988f26a4b161d05c8ca58f63fb1f1b6b9a74be45"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:786d6b57026e7e04d184313c1359ac3d68002c33e4b1042ca58c362f1d09ff58"}, + {file = "lxml-4.9.4-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:95ae6c5a196e2f239150aa4a479967351df7f44800c93e5a975ec726fef005e2"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-macosx_11_0_x86_64.whl", hash = "sha256:9b556596c49fa1232b0fff4b0e69b9d4083a502e60e404b44341e2f8fb7187f5"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_24_i686.whl", hash = "sha256:cc02c06e9e320869d7d1bd323df6dd4281e78ac2e7f8526835d3d48c69060683"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:857d6565f9aa3464764c2cb6a2e3c2e75e1970e877c188f4aeae45954a314e0c"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c42ae7e010d7d6bc51875d768110c10e8a59494855c3d4c348b068f5fb81fdcd"}, + {file = "lxml-4.9.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f10250bb190fb0742e3e1958dd5c100524c2cc5096c67c8da51233f7448dc137"}, + {file = "lxml-4.9.4.tar.gz", hash = "sha256:b1541e50b78e15fa06a2670157a1962ef06591d4c998b998047fff5e3236880e"}, +] + +[package.extras] +cssselect = ["cssselect (>=0.7)"] +html5 = ["html5lib"] +htmlsoup = ["BeautifulSoup4"] +source = ["Cython (==0.29.37)"] + +[[package]] +name = "pan-os-python" +version = "1.12.1" +description = "Framework for interacting with Palo Alto Networks devices via API" +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,>=2.7" +files = [ + {file = "pan_os_python-1.12.1-py2.py3-none-any.whl", hash = "sha256:71d149e259c2077f83beebe29b25a8b4e53adbd28c12cb167065a010d2e92368"}, + {file = "pan_os_python-1.12.1.tar.gz", hash = "sha256:41d7871547919cb5c3b7d3ebe8c9d1797b8a938c8366b53307e64375d65e69dc"}, +] + +[package.dependencies] +pan-python = ">=0.17.0,<0.18.0" + +[[package]] +name = "pan-python" +version = "0.17.0" +description = "Multi-tool set for Palo Alto Networks PAN-OS, Panorama, WildFire and AutoFocus" +optional = false +python-versions = "*" +files = [ + {file = "pan-python-0.17.0.tar.gz", hash = "sha256:9c074ea2f69a63996a6fefe8935d60dca61660e14715ac19d257ea9b1c41c6e2"}, + {file = "pan_python-0.17.0-py2.py3-none-any.whl", hash = "sha256:f4674e40763c46d5933244b3059a57884e4e28205ef6d0f9ce2dc2013e3db010"}, +] + +[[package]] +name = "pydantic" +version = "2.5.3" +description = "Data validation using Python type hints" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pydantic-2.5.3-py3-none-any.whl", hash = "sha256:d0caf5954bee831b6bfe7e338c32b9e30c85dfe080c843680783ac2b631673b4"}, + {file = "pydantic-2.5.3.tar.gz", hash = "sha256:b3ef57c62535b0941697cce638c08900d87fcb67e29cfa99e8a68f747f393f7a"}, +] + +[package.dependencies] +annotated-types = ">=0.4.0" +importlib-metadata = {version = "*", markers = "python_version == \"3.7\""} +pydantic-core = "2.14.6" +typing-extensions = ">=4.6.1" + +[package.extras] +email = ["email-validator (>=2.0.0)"] + +[[package]] +name = "pydantic-core" +version = "2.14.6" +description = "" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pydantic_core-2.14.6-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:72f9a942d739f09cd42fffe5dc759928217649f070056f03c70df14f5770acf9"}, + {file = "pydantic_core-2.14.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6a31d98c0d69776c2576dda4b77b8e0c69ad08e8b539c25c7d0ca0dc19a50d6c"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5aa90562bc079c6c290f0512b21768967f9968e4cfea84ea4ff5af5d917016e4"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:370ffecb5316ed23b667d99ce4debe53ea664b99cc37bfa2af47bc769056d534"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f85f3843bdb1fe80e8c206fe6eed7a1caeae897e496542cee499c374a85c6e08"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9862bf828112e19685b76ca499b379338fd4c5c269d897e218b2ae8fcb80139d"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:036137b5ad0cb0004c75b579445a1efccd072387a36c7f217bb8efd1afbe5245"}, + {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:92879bce89f91f4b2416eba4429c7b5ca22c45ef4a499c39f0c5c69257522c7c"}, + {file = "pydantic_core-2.14.6-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0c08de15d50fa190d577e8591f0329a643eeaed696d7771760295998aca6bc66"}, + {file = "pydantic_core-2.14.6-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:36099c69f6b14fc2c49d7996cbf4f87ec4f0e66d1c74aa05228583225a07b590"}, + {file = "pydantic_core-2.14.6-cp310-none-win32.whl", hash = "sha256:7be719e4d2ae6c314f72844ba9d69e38dff342bc360379f7c8537c48e23034b7"}, + {file = "pydantic_core-2.14.6-cp310-none-win_amd64.whl", hash = "sha256:36fa402dcdc8ea7f1b0ddcf0df4254cc6b2e08f8cd80e7010d4c4ae6e86b2a87"}, + {file = "pydantic_core-2.14.6-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:dea7fcd62915fb150cdc373212141a30037e11b761fbced340e9db3379b892d4"}, + {file = "pydantic_core-2.14.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ffff855100bc066ff2cd3aa4a60bc9534661816b110f0243e59503ec2df38421"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b027c86c66b8627eb90e57aee1f526df77dc6d8b354ec498be9a757d513b92b"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:00b1087dabcee0b0ffd104f9f53d7d3eaddfaa314cdd6726143af6bc713aa27e"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:75ec284328b60a4e91010c1acade0c30584f28a1f345bc8f72fe8b9e46ec6a96"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7e1f4744eea1501404b20b0ac059ff7e3f96a97d3e3f48ce27a139e053bb370b"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2602177668f89b38b9f84b7b3435d0a72511ddef45dc14446811759b82235a1"}, + {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6c8edaea3089bf908dd27da8f5d9e395c5b4dc092dbcce9b65e7156099b4b937"}, + {file = "pydantic_core-2.14.6-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:478e9e7b360dfec451daafe286998d4a1eeaecf6d69c427b834ae771cad4b622"}, + {file = "pydantic_core-2.14.6-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b6ca36c12a5120bad343eef193cc0122928c5c7466121da7c20f41160ba00ba2"}, + {file = "pydantic_core-2.14.6-cp311-none-win32.whl", hash = "sha256:2b8719037e570639e6b665a4050add43134d80b687288ba3ade18b22bbb29dd2"}, + {file = "pydantic_core-2.14.6-cp311-none-win_amd64.whl", hash = "sha256:78ee52ecc088c61cce32b2d30a826f929e1708f7b9247dc3b921aec367dc1b23"}, + {file = "pydantic_core-2.14.6-cp311-none-win_arm64.whl", hash = "sha256:a19b794f8fe6569472ff77602437ec4430f9b2b9ec7a1105cfd2232f9ba355e6"}, + {file = "pydantic_core-2.14.6-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:667aa2eac9cd0700af1ddb38b7b1ef246d8cf94c85637cbb03d7757ca4c3fdec"}, + {file = "pydantic_core-2.14.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdee837710ef6b56ebd20245b83799fce40b265b3b406e51e8ccc5b85b9099b7"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c5bcf3414367e29f83fd66f7de64509a8fd2368b1edf4351e862910727d3e51"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26a92ae76f75d1915806b77cf459811e772d8f71fd1e4339c99750f0e7f6324f"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a983cca5ed1dd9a35e9e42ebf9f278d344603bfcb174ff99a5815f953925140a"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cb92f9061657287eded380d7dc455bbf115430b3aa4741bdc662d02977e7d0af"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4ace1e220b078c8e48e82c081e35002038657e4b37d403ce940fa679e57113b"}, + {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef633add81832f4b56d3b4c9408b43d530dfca29e68fb1b797dcb861a2c734cd"}, + {file = "pydantic_core-2.14.6-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7e90d6cc4aad2cc1f5e16ed56e46cebf4877c62403a311af20459c15da76fd91"}, + {file = "pydantic_core-2.14.6-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e8a5ac97ea521d7bde7621d86c30e86b798cdecd985723c4ed737a2aa9e77d0c"}, + {file = "pydantic_core-2.14.6-cp312-none-win32.whl", hash = "sha256:f27207e8ca3e5e021e2402ba942e5b4c629718e665c81b8b306f3c8b1ddbb786"}, + {file = "pydantic_core-2.14.6-cp312-none-win_amd64.whl", hash = "sha256:b3e5fe4538001bb82e2295b8d2a39356a84694c97cb73a566dc36328b9f83b40"}, + {file = "pydantic_core-2.14.6-cp312-none-win_arm64.whl", hash = "sha256:64634ccf9d671c6be242a664a33c4acf12882670b09b3f163cd00a24cffbd74e"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-macosx_10_7_x86_64.whl", hash = "sha256:24368e31be2c88bd69340fbfe741b405302993242ccb476c5c3ff48aeee1afe0"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:e33b0834f1cf779aa839975f9d8755a7c2420510c0fa1e9fa0497de77cd35d2c"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6af4b3f52cc65f8a0bc8b1cd9676f8c21ef3e9132f21fed250f6958bd7223bed"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15687d7d7f40333bd8266f3814c591c2e2cd263fa2116e314f60d82086e353a"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:095b707bb287bfd534044166ab767bec70a9bba3175dcdc3371782175c14e43c"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94fc0e6621e07d1e91c44e016cc0b189b48db053061cc22d6298a611de8071bb"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ce830e480f6774608dedfd4a90c42aac4a7af0a711f1b52f807130c2e434c06"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a306cdd2ad3a7d795d8e617a58c3a2ed0f76c8496fb7621b6cd514eb1532cae8"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:2f5fa187bde8524b1e37ba894db13aadd64faa884657473b03a019f625cee9a8"}, + {file = "pydantic_core-2.14.6-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:438027a975cc213a47c5d70672e0d29776082155cfae540c4e225716586be75e"}, + {file = "pydantic_core-2.14.6-cp37-none-win32.whl", hash = "sha256:f96ae96a060a8072ceff4cfde89d261837b4294a4f28b84a28765470d502ccc6"}, + {file = "pydantic_core-2.14.6-cp37-none-win_amd64.whl", hash = "sha256:e646c0e282e960345314f42f2cea5e0b5f56938c093541ea6dbf11aec2862391"}, + {file = "pydantic_core-2.14.6-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:db453f2da3f59a348f514cfbfeb042393b68720787bbef2b4c6068ea362c8149"}, + {file = "pydantic_core-2.14.6-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3860c62057acd95cc84044e758e47b18dcd8871a328ebc8ccdefd18b0d26a21b"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36026d8f99c58d7044413e1b819a67ca0e0b8ebe0f25e775e6c3d1fabb3c38fb"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8ed1af8692bd8d2a29d702f1a2e6065416d76897d726e45a1775b1444f5928a7"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:314ccc4264ce7d854941231cf71b592e30d8d368a71e50197c905874feacc8a8"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:982487f8931067a32e72d40ab6b47b1628a9c5d344be7f1a4e668fb462d2da42"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dbe357bc4ddda078f79d2a36fc1dd0494a7f2fad83a0a684465b6f24b46fe80"}, + {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f6ffc6701a0eb28648c845f4945a194dc7ab3c651f535b81793251e1185ac3d"}, + {file = "pydantic_core-2.14.6-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:7f5025db12fc6de7bc1104d826d5aee1d172f9ba6ca936bf6474c2148ac336c1"}, + {file = "pydantic_core-2.14.6-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:dab03ed811ed1c71d700ed08bde8431cf429bbe59e423394f0f4055f1ca0ea60"}, + {file = "pydantic_core-2.14.6-cp38-none-win32.whl", hash = "sha256:dfcbebdb3c4b6f739a91769aea5ed615023f3c88cb70df812849aef634c25fbe"}, + {file = "pydantic_core-2.14.6-cp38-none-win_amd64.whl", hash = "sha256:99b14dbea2fdb563d8b5a57c9badfcd72083f6006caf8e126b491519c7d64ca8"}, + {file = "pydantic_core-2.14.6-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:4ce8299b481bcb68e5c82002b96e411796b844d72b3e92a3fbedfe8e19813eab"}, + {file = "pydantic_core-2.14.6-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b9a9d92f10772d2a181b5ca339dee066ab7d1c9a34ae2421b2a52556e719756f"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd9e98b408384989ea4ab60206b8e100d8687da18b5c813c11e92fd8212a98e0"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f86f1f318e56f5cbb282fe61eb84767aee743ebe32c7c0834690ebea50c0a6b"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86ce5fcfc3accf3a07a729779d0b86c5d0309a4764c897d86c11089be61da160"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dcf1978be02153c6a31692d4fbcc2a3f1db9da36039ead23173bc256ee3b91b"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eedf97be7bc3dbc8addcef4142f4b4164066df0c6f36397ae4aaed3eb187d8ab"}, + {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d5f916acf8afbcab6bacbb376ba7dc61f845367901ecd5e328fc4d4aef2fcab0"}, + {file = "pydantic_core-2.14.6-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8a14c192c1d724c3acbfb3f10a958c55a2638391319ce8078cb36c02283959b9"}, + {file = "pydantic_core-2.14.6-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0348b1dc6b76041516e8a854ff95b21c55f5a411c3297d2ca52f5528e49d8411"}, + {file = "pydantic_core-2.14.6-cp39-none-win32.whl", hash = "sha256:de2a0645a923ba57c5527497daf8ec5df69c6eadf869e9cd46e86349146e5975"}, + {file = "pydantic_core-2.14.6-cp39-none-win_amd64.whl", hash = "sha256:aca48506a9c20f68ee61c87f2008f81f8ee99f8d7f0104bff3c47e2d148f89d9"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:d5c28525c19f5bb1e09511669bb57353d22b94cf8b65f3a8d141c389a55dec95"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:78d0768ee59baa3de0f4adac9e3748b4b1fffc52143caebddfd5ea2961595277"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b93785eadaef932e4fe9c6e12ba67beb1b3f1e5495631419c784ab87e975670"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a874f21f87c485310944b2b2734cd6d318765bcbb7515eead33af9641816506e"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b89f4477d915ea43b4ceea6756f63f0288941b6443a2b28c69004fe07fde0d0d"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:172de779e2a153d36ee690dbc49c6db568d7b33b18dc56b69a7514aecbcf380d"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:dfcebb950aa7e667ec226a442722134539e77c575f6cfaa423f24371bb8d2e94"}, + {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:55a23dcd98c858c0db44fc5c04fc7ed81c4b4d33c653a7c45ddaebf6563a2f66"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-macosx_10_7_x86_64.whl", hash = "sha256:4241204e4b36ab5ae466ecec5c4c16527a054c69f99bba20f6f75232a6a534e2"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e574de99d735b3fc8364cba9912c2bec2da78775eba95cbb225ef7dda6acea24"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1302a54f87b5cd8528e4d6d1bf2133b6aa7c6122ff8e9dc5220fbc1e07bffebd"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8e81e4b55930e5ffab4a68db1af431629cf2e4066dbdbfef65348b8ab804ea8"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c99462ffc538717b3e60151dfaf91125f637e801f5ab008f81c402f1dff0cd0f"}, + {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e4cf2d5829f6963a5483ec01578ee76d329eb5caf330ecd05b3edd697e7d768a"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:cf10b7d58ae4a1f07fccbf4a0a956d705356fea05fb4c70608bb6fa81d103cda"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:399ac0891c284fa8eb998bcfa323f2234858f5d2efca3950ae58c8f88830f145"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c6a5c79b28003543db3ba67d1df336f253a87d3112dac3a51b94f7d48e4c0e1"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:599c87d79cab2a6a2a9df4aefe0455e61e7d2aeede2f8577c1b7c0aec643ee8e"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e166ad47ba900f2542a80d83f9fc65fe99eb63ceec4debec160ae729824052"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3a0b5db001b98e1c649dd55afa928e75aa4087e587b9524a4992316fa23c9fba"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:747265448cb57a9f37572a488a57d873fd96bf51e5bb7edb52cfb37124516da4"}, + {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:7ebe3416785f65c28f4f9441e916bfc8a54179c8dea73c23023f7086fa601c5d"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:86c963186ca5e50d5c8287b1d1c9d3f8f024cbe343d048c5bd282aec2d8641f2"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e0641b506486f0b4cd1500a2a65740243e8670a2549bb02bc4556a83af84ae03"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71d72ca5eaaa8d38c8df16b7deb1a2da4f650c41b58bb142f3fb75d5ad4a611f"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27e524624eace5c59af499cd97dc18bb201dc6a7a2da24bfc66ef151c69a5f2a"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3dde6cac75e0b0902778978d3b1646ca9f438654395a362cb21d9ad34b24acf"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:00646784f6cd993b1e1c0e7b0fdcbccc375d539db95555477771c27555e3c556"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:23598acb8ccaa3d1d875ef3b35cb6376535095e9405d91a3d57a8c7db5d29341"}, + {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7f41533d7e3cf9520065f610b41ac1c76bc2161415955fbcead4981b22c7611e"}, + {file = "pydantic_core-2.14.6.tar.gz", hash = "sha256:1fd0c1d395372843fba13a51c28e3bb9d59bd7aebfeb17358ffaaa1e4dbbe948"}, +] + +[package.dependencies] +typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0" + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "typing-extensions" +version = "4.7.1" +description = "Backported and Experimental Type Hints for Python 3.7+" +optional = false +python-versions = ">=3.7" +files = [ + {file = "typing_extensions-4.7.1-py3-none-any.whl", hash = "sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36"}, + {file = "typing_extensions-4.7.1.tar.gz", hash = "sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2"}, +] + +[[package]] +name = "urllib3" +version = "2.0.7" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.7" +files = [ + {file = "urllib3-2.0.7-py3-none-any.whl", hash = "sha256:fdb6d215c776278489906c2f8916e6e7d4f5a9b602ccbcfdf7f016fc8da0596e"}, + {file = "urllib3-2.0.7.tar.gz", hash = "sha256:c97dfde1f7bd43a71c8d2a58e369e9b2bf692d1334ea9f9cae55add7d0dd0f84"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +secure = ["certifi", "cryptography (>=1.9)", "idna (>=2.0.0)", "pyopenssl (>=17.1.0)", "urllib3-secure-extra"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "xmltodict" +version = "0.13.0" +description = "Makes working with XML feel like you are working with JSON" +optional = false +python-versions = ">=3.4" +files = [ + {file = "xmltodict-0.13.0-py2.py3-none-any.whl", hash = "sha256:aa89e8fd76320154a40d19a0df04a4695fb9dc5ba977cbb68ab3e4eb225e7852"}, + {file = "xmltodict-0.13.0.tar.gz", hash = "sha256:341595a488e3e01a85a9d8911d8912fd922ede5fecc4dce437eb4b6c8d037e56"}, +] + +[[package]] +name = "zipp" +version = "3.15.0" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.7" +files = [ + {file = "zipp-3.15.0-py3-none-any.whl", hash = "sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556"}, + {file = "zipp-3.15.0.tar.gz", hash = "sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-O", "flake8 (<5)", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=1.3)", "pytest-flake8", "pytest-mypy (>=0.9.1)"] + +[metadata] +lock-version = "2.0" +python-versions = ">=3.7.0,<4.0.0" +content-hash = "cea885a19c4c5bd94e1f5ccaf9ae0b8520042bdd3e98e5b2ce5469c85f665eae" diff --git a/public/index.html b/public/index.html new file mode 100644 index 0000000..3f5ecfe --- /dev/null +++ b/public/index.html @@ -0,0 +1,7 @@ + + + + + + + diff --git a/public/pa_api.html b/public/pa_api.html new file mode 100644 index 0000000..129ee56 --- /dev/null +++ b/public/pa_api.html @@ -0,0 +1,248 @@ + + + + + + + pa_api API documentation + + + + + + + + + +
+
+

+pa_api

+ + + + + + + 
 1from . import panorama, restapi, xmlapi
+ 2from .panorama import Panorama
+ 3from .restapi.restapi import PanoramaClient
+ 4from .xmlapi import XMLApi, types
+ 5
+ 6__all__ = [
+ 7    "panorama",
+ 8    "restapi",
+ 9    "xmlapi",
+10]
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/panorama.html b/public/pa_api/panorama.html new file mode 100644 index 0000000..3f2dced --- /dev/null +++ b/public/pa_api/panorama.html @@ -0,0 +1,531 @@ + + + + + + + pa_api.panorama API documentation + + + + + + + + + +
+
+

+pa_api.panorama

+ + + + + + + 
 1from panos import panorama
+ 2
+ 3from .utils import clean_url_host
+ 4
+ 5
+ 6class Panorama(panorama.Panorama):
+ 7    """
+ 8    Wrapper class for the Panorama class from pan-os-python library:
+ 9    https://pan-os-python.readthedocs.io/en/latest/readme.html#features
+10
+11    Added features are:
+12    - hostname can be provided with and without the scheme
+13        - https://mydomain.com
+14        - mydomain.com
+15        - https://mydomain.com:443
+16      Are all valid
+17    """
+18
+19    def __init__(
+20        self,
+21        hostname,
+22        api_username=None,
+23        api_password=None,
+24        api_key=None,
+25        port=None,
+26        *args,
+27        **kwargs,
+28    ):
+29        _, hostname, _port = clean_url_host(hostname)
+30        port = port or _port or 443
+31        return super().__init__(
+32            hostname, api_username, api_password, api_key, port, *args, **kwargs
+33        )
+
+ + +
+
+ +
+ + class + Panorama(panos.panorama.Panorama): + + + +
+ + 
 7class Panorama(panorama.Panorama):
+ 8    """
+ 9    Wrapper class for the Panorama class from pan-os-python library:
+10    https://pan-os-python.readthedocs.io/en/latest/readme.html#features
+11
+12    Added features are:
+13    - hostname can be provided with and without the scheme
+14        - https://mydomain.com
+15        - mydomain.com
+16        - https://mydomain.com:443
+17      Are all valid
+18    """
+19
+20    def __init__(
+21        self,
+22        hostname,
+23        api_username=None,
+24        api_password=None,
+25        api_key=None,
+26        port=None,
+27        *args,
+28        **kwargs,
+29    ):
+30        _, hostname, _port = clean_url_host(hostname)
+31        port = port or _port or 443
+32        return super().__init__(
+33            hostname, api_username, api_password, api_key, port, *args, **kwargs
+34        )
+
+ + +

Wrapper class for the Panorama class from pan-os-python library: +https://pan-os-python.readthedocs.io/en/latest/readme.html#features

+ +

Added features are:

+ + +
+ + +
+ +
+ + Panorama( hostname, api_username=None, api_password=None, api_key=None, port=None, *args, **kwargs) + + + +
+ + 
20    def __init__(
+21        self,
+22        hostname,
+23        api_username=None,
+24        api_password=None,
+25        api_key=None,
+26        port=None,
+27        *args,
+28        **kwargs,
+29    ):
+30        _, hostname, _port = clean_url_host(hostname)
+31        port = port or _port or 443
+32        return super().__init__(
+33            hostname, api_username, api_password, api_key, port, *args, **kwargs
+34        )
+
+ + +

Initialize PanDevice

+
+ + +
+
+
Inherited Members
+
+
panos.panorama.Panorama
+
FIREWALL_CLASS
+
NAME
+
DEFAULT_VSYS
+
CHILDTYPES
+
OPSTATES
+
op
+
xpath_vsys
+
xpath_panorama
+
panorama
+
commit_all
+
refresh_devices
+
generate_vm_auth_key
+
get_vm_auth_keys
+
refresh_shared_objects
+ +
+
panos.base.PanDevice
+
hostname
+
port
+
is_virtual
+
timeout
+
interval
+
serial
+
config_locked
+
commit_locked
+
lock_before_change
+
shared_lock_before_change
+
config_changed
+
software
+
content
+
version
+
content_version
+
platform
+
ha_failed
+
userid
+
predefined
+
get_device_version
+
create_from_device
+
XapiWrapper
+
id
+
api_key
+
xapi
+
update_connection_method
+
generate_xapi
+
set_config_changed
+
xpath_root
+
xpath_mgtconfig
+
xpath_device
+
devices
+
show_system_info
+
refresh_system_info
+
refresh_version
+
set_hostname
+
set_dns_servers
+
set_ntp_servers
+
pending_changes
+
add_commit_lock
+
remove_commit_lock
+
add_config_lock
+
remove_config_lock
+
remove_all_locks
+
check_commit_locks
+
check_config_locks
+
revert_to_running_configuration
+
restart
+
ha_peer
+
set_ha_peers
+
ha_pair
+
active
+
passive
+
is_active
+
activate
+
toggle_ha_active
+
update_ha_active
+
set_failed
+
map_ha
+
show_highavailability_state
+
refresh_ha_active
+
synchronize_config
+
config_sync_state
+
config_synced
+
commit
+
syncjob
+
syncreboot
+
watch_op
+
nearest_pandevice
+
request_license_info
+
fetch_licenses_from_license_server
+
activate_feature_using_authorization_code
+
request_password_hash
+
test_security_policy_match
+
clock
+
plugins
+
whoami
+ +
+
panos.base.PanObject
+
XPATH
+
SUFFIX
+
ROOT
+
CHILDMETHODS
+
HA_SYNC
+
TEMPLATE_NATIVE
+
parent
+
children
+
variables
+
vsys
+
uid
+
add
+
insert
+
extend
+
pop
+
remove
+
remove_by_name
+
removeall
+
xpath
+
xpath_nosuffix
+
xpath_short
+
element
+
element_str
+
equal
+
apply
+
create
+
delete
+
update
+
rename
+
move
+
refresh
+
refresh_variable
+
devicegroup
+
find
+
findall
+
find_or_create
+
findall_or_create
+
find_index
+
refreshall
+
refreshall_from_xml
+
xml_merge
+
about
+
create_similar
+
apply_similar
+
delete_similar
+
dot
+
tree
+
fulltree
+
retrieve_panos_version
+
hierarchy_info
+ +
+
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/restapi.html b/public/pa_api/restapi.html new file mode 100644 index 0000000..07fd462 --- /dev/null +++ b/public/pa_api/restapi.html @@ -0,0 +1,446 @@ + + + + + + + pa_api.restapi API documentation + + + + + + + + + +
+
+

+pa_api.restapi

+ + + + + + + 
1from . import rest_resources, restapi
+2from .restapi import PanoramaClient
+3
+4__all__ = [
+5    "restapi",
+6    "rest_resources",
+7    "PanoramaClient",
+8]
+
+ + +
+
+ +
+ + class + PanoramaClient: + + + +
+ + 
266class PanoramaClient:
+267    """
+268    Wrapper for the PaloAlto REST API
+269    Resources (e.g. Addresses, Tags, ..) are grouped under their resource types.
+270    See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4
+271
+272    Attributes:
+273
+274        - objects: groups all the objects (Address, Tag, Service, ...)
+275        - policies: groups all the policies (Security, NAT, ...)
+276        - network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)
+277        - device: groups all device-related resources (only VirtualSystems)
+278        - panorama: groups all panorama-management-related resources (only DeviceGroups)
+279    """
+280
+281    objects: PanoramaObjectsResourceType
+282    policies: PanoramaPoliciesResourceType
+283    network: PanoramaNetworkResourceType
+284    device: PanoramaDevicesResourceType
+285    panorama: PanoramaPanoramaResourceType
+286
+287    def __init__(
+288        self,
+289        domain,
+290        api_key=None,
+291        version="v10.1",
+292        verify=False,
+293        verbose=False,
+294    ):
+295        domain, _, _ = clean_url_host(domain)
+296        client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify)
+297        self.client = client
+298        self.objects = PanoramaObjectsResourceType(client, domain, version=version)
+299        self.policies = PanoramaPoliciesResourceType(client, domain, version=version)
+300        self.network = PanoramaNetworkResourceType(client, domain, version=version)
+301        self.device = PanoramaDevicesResourceType(client, domain, version=version)
+302        self.panorama = PanoramaPanoramaResourceType(client, domain, version=version)
+
+ + +

Wrapper for the PaloAlto REST API +Resources (e.g. Addresses, Tags, ..) are grouped under their resource types. +See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4

+ +

Attributes:

+ +
- objects: groups all the objects (Address, Tag, Service, ...)
+- policies: groups all the policies (Security, NAT, ...)
+- network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)
+- device: groups all device-related resources (only VirtualSystems)
+- panorama: groups all panorama-management-related resources (only DeviceGroups)
+
+
+ + +
+ +
+ + PanoramaClient(domain, api_key=None, version='v10.1', verify=False, verbose=False) + + + +
+ + 
287    def __init__(
+288        self,
+289        domain,
+290        api_key=None,
+291        version="v10.1",
+292        verify=False,
+293        verbose=False,
+294    ):
+295        domain, _, _ = clean_url_host(domain)
+296        client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify)
+297        self.client = client
+298        self.objects = PanoramaObjectsResourceType(client, domain, version=version)
+299        self.policies = PanoramaPoliciesResourceType(client, domain, version=version)
+300        self.network = PanoramaNetworkResourceType(client, domain, version=version)
+301        self.device = PanoramaDevicesResourceType(client, domain, version=version)
+302        self.panorama = PanoramaPanoramaResourceType(client, domain, version=version)
+
+ + + + +
+ + + + + +
+
+ client + + +
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/restapi/rest_resources.html b/public/pa_api/restapi/rest_resources.html new file mode 100644 index 0000000..b45f184 --- /dev/null +++ b/public/pa_api/restapi/rest_resources.html @@ -0,0 +1,2774 @@ + + + + + + + pa_api.restapi.rest_resources API documentation + + + + + + + + + +
+
+

+pa_api.restapi.rest_resources

+ + + + + + + 
  1from functools import wraps
+  2from multiprocessing.pool import ThreadPool as Pool
+  3from typing import ClassVar
+  4
+  5# List of existing resources
+  6# https://docs.paloaltonetworks.com/pan-os/10-2/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api
+  7
+  8DEFAULT_PARAMS = {
+  9    "location": "device-group",
+ 10}
+ 11
+ 12
+ 13class BasePanoramaResource:
+ 14    def __init__(
+ 15        self,
+ 16        client,
+ 17        host,
+ 18        resource_type,
+ 19        resource,
+ 20        version="v10.1",
+ 21        default_params=None,
+ 22    ):
+ 23        """
+ 24        client:
+ 25        """
+ 26        self.DEFAULT_PARAMS = default_params or DEFAULT_PARAMS
+ 27        if not host.startswith("http"):
+ 28            host = "https://" + host
+ 29        self._client = client
+ 30        self._name = f"{resource_type}/{resource}"
+ 31        self._url = f"{host}/restapi/{version}/{resource_type}/{resource}"
+ 32
+ 33    def __str__(self):
+ 34        return self._name
+ 35
+ 36    def __repr__(self):
+ 37        return str(self)
+ 38
+ 39    def get(self, params=None, headers=None, data=None, verify=None):
+ 40        return self._client.get(
+ 41            self._url,
+ 42            params=params,
+ 43            headers=headers,
+ 44            data=data,
+ 45            verify=verify,
+ 46        )
+ 47
+ 48    def delete(self, params=None, headers=None, data=None, verify=None):
+ 49        return self._client.delete(
+ 50            self._url,
+ 51            params=params,
+ 52            headers=headers,
+ 53            data=data,
+ 54            verify=verify,
+ 55        )
+ 56
+ 57
+ 58class PanoramaResource(BasePanoramaResource):
+ 59    def get(
+ 60        self,
+ 61        device_group=None,
+ 62        name=None,
+ 63        inherited=True,
+ 64        params=None,
+ 65        headers=None,
+ 66        data=None,
+ 67        verify=None,
+ 68    ):
+ 69        if params is None:
+ 70            params = {}
+ 71        _params = {**self.DEFAULT_PARAMS, **params}
+ 72        if name is not None:
+ 73            _params["name"] = name
+ 74
+ 75        def func(params):
+ 76            params = {**_params, **params}
+ 77            res = self._client.get(
+ 78                self._url,
+ 79                params=params,
+ 80                headers=headers,
+ 81                data=data,
+ 82                verify=verify,
+ 83            )
+ 84            if not isinstance(res, list):
+ 85                return []  # Error happened
+ 86            if not inherited:
+ 87                res = [r for r in res if r["@device-group"] == r["@loc"]]
+ 88            return res
+ 89
+ 90        if device_group is None:
+ 91            return func(params)
+ 92        if isinstance(device_group, str):
+ 93            device_group = [device_group]
+ 94        if len(device_group) == 1:
+ 95            params = {"device-group": device_group}
+ 96            return func(params)
+ 97        if len(device_group) > 1:
+ 98            params_list = [{"device-group": dg} for dg in device_group]
+ 99            with Pool(len(device_group)) as pool:
+100                data = pool.map(func, params_list)
+101            return [record for res in data for record in res]
+102        return None
+103
+104    def delete(
+105        self,
+106        device_group=None,
+107        name=None,
+108        params=None,
+109        headers=None,
+110        data=None,
+111        verify=None,
+112    ):
+113        if params is None:
+114            params = {}
+115        params = {**self.DEFAULT_PARAMS, **params}
+116        if device_group is not None:
+117            params["device-group"] = device_group
+118        if name is not None:
+119            params["name"] = name
+120        return self._client.delete(
+121            self._url,
+122            params=params,
+123            headers=headers,
+124            data=data,
+125            verify=verify,
+126        )
+127
+128
+129class GroupedResources:
+130    def __init__(self, *resources):
+131        self._resources = resources
+132
+133    def _grouped(self, method, *args, **kwargs):
+134        params_list = [(getattr(r, method), args, kwargs) for r in self._resources]
+135
+136        def func(args):
+137            f, args, kwargs = args
+138            return f(*args, **kwargs)
+139
+140        with Pool(len(self._resources)) as pool:
+141            data = pool.map(func, params_list)
+142        return [record for res in data for record in res]
+143
+144    @wraps(PanoramaResource.get)
+145    def get(self, *args, **kwargs):
+146        return self._grouped("get", *args, **kwargs)
+147
+148    # def delete(self, params={}, headers={}, data=None, verify=None):
+149    #     return self._client.delete(
+150    #         self._url,
+151    #         params=params, headers=headers,
+152    #         data=data, verify=verify
+153    #     )
+154
+155
+156class PanoramaResourceType:
+157    def __init__(self, client, resource_type):
+158        self._client = client
+159        self._name = resource_type
+160
+161    def __str__(self):
+162        return self._name
+163
+164    def __repr__(self):
+165        return str(self)
+166
+167
+168class PanoramaPanoramaResourceType(PanoramaResourceType):
+169    resource_type = "Panorama"
+170
+171    def __init__(self, client, domain, version="v10.1"):
+172        resource_type = self.resource_type
+173        super().__init__(client, resource_type)
+174
+175        def resource(name):
+176            return BasePanoramaResource(
+177                client,
+178                domain,
+179                resource_type,
+180                name,
+181                version=version,
+182            )
+183
+184        self.DeviceGroups = resource("DeviceGroups")
+185
+186
+187class PanoramaObjectsResourceType(PanoramaResourceType):
+188    """
+189    Represent the 'Objects' subsection in the API.
+190    """
+191
+192    resource_type = "Objects"
+193
+194    def __init__(self, client, domain, version="v10.1"):
+195        resource_type = self.resource_type
+196        super().__init__(client, resource_type)
+197
+198        def resource(name):
+199            return PanoramaResource(
+200                client,
+201                domain,
+202                resource_type,
+203                name,
+204                version=version,
+205            )
+206
+207        self.Addresses = resource("Addresses")
+208        self.AddressGroups = resource("AddressGroups")
+209        self.Regions = resource("Regions")
+210        self.Applications = resource("Applications")
+211        self.ApplicationGroups = resource("ApplicationGroups")
+212        self.ApplicationFilters = resource("ApplicationFilters")
+213        self.Services = resource("Services")
+214        self.ServiceGroups = resource("ServiceGroups")
+215        self.Tags = resource("Tags")
+216        self.GlobalProtectHIPObjects = resource("GlobalProtectHIPObjects")
+217        self.GlobalProtectHIPProfiles = resource("GlobalProtectHIPProfiles")
+218        self.ExternalDynamicLists = resource("ExternalDynamicLists")
+219        self.CustomDataPatterns = resource("CustomDataPatterns")
+220        self.CustomSpywareSignatures = resource("CustomSpywareSignatures")
+221        self.CustomVulnerabilitySignatures = resource("CustomVulnerabilitySignatures")
+222        self.CustomURLCategories = resource("CustomURLCategories")
+223        self.AntivirusSecurityProfiles = resource("AntivirusSecurityProfiles")
+224        self.AntiSpywareSecurityProfiles = resource("AntiSpywareSecurityProfiles")
+225        self.VulnerabilityProtectionSecurityProfiles = resource(
+226            "VulnerabilityProtectionSecurityProfiles",
+227        )
+228        self.URLFilteringSecurityProfiles = resource("URLFilteringSecurityProfiles")
+229        self.FileBlockingSecurityProfiles = resource("FileBlockingSecurityProfiles")
+230        self.WildFireAnalysisSecurityProfiles = resource(
+231            "WildFireAnalysisSecurityProfiles",
+232        )
+233        self.DataFilteringSecurityProfiles = resource("DataFilteringSecurityProfiles")
+234        self.DoSProtectionSecurityProfiles = resource("DoSProtectionSecurityProfiles")
+235        self.SecurityProfileGroups = resource("SecurityProfileGroups")
+236        self.LogForwardingProfiles = resource("LogForwardingProfiles")
+237        self.AuthenticationEnforcements = resource("AuthenticationEnforcements")
+238        self.DecryptionProfiles = resource("DecryptionProfiles")
+239        self.DecryptionForwardingProfiles = resource("DecryptionForwardingProfiles")
+240        self.Schedules = resource("Schedules")
+241        self.SDWANPathQualityProfiles = resource("SDWANPathQualityProfiles")
+242        self.SDWANTrafficDistributionProfiles = resource(
+243            "SDWANTrafficDistributionProfiles",
+244        )
+245
+246
+247class PanoramaPoliciesResourceType(PanoramaResourceType):
+248    """
+249    Represent the 'Policies' subsection in the API.
+250    """
+251
+252    resource_type = "Policies"
+253
+254    def __init__(self, client, domain, version="v10.1"):
+255        resource_type = self.resource_type
+256        super().__init__(client, resource_type)
+257
+258        def resource(name):
+259            return PanoramaResource(
+260                client,
+261                domain,  # host
+262                resource_type,
+263                name,
+264                version=version,
+265            )
+266
+267        self.SecurityPreRules = resource("SecurityPreRules")
+268        self.SecurityPostRules = resource("SecurityPostRules")
+269        self.SecurityRules = GroupedResources(
+270            self.SecurityPreRules,
+271            self.SecurityPostRules,
+272        )
+273        self.NATPreRules = resource("NATPreRules")
+274        self.NATPostRules = resource("NATPostRules")
+275        self.NATRules = GroupedResources(self.NATPreRules, self.NATPostRules)
+276        self.QoSPreRules = resource("QoSPreRules")
+277        self.QoSPostRules = resource("QoSPostRules")
+278        self.QoSRules = GroupedResources(self.QoSPreRules, self.QoSPostRules)
+279        self.PolicyBasedForwardingPreRules = resource("PolicyBasedForwardingPreRules")
+280        self.PolicyBasedForwardingPostRules = resource("PolicyBasedForwardingPostRules")
+281        self.PolicyBasedForwardingRules = GroupedResources(
+282            self.PolicyBasedForwardingPreRules,
+283            self.PolicyBasedForwardingPostRules,
+284        )
+285        self.DecryptionPreRules = resource("DecryptionPreRules")
+286        self.DecryptionPostRules = resource("DecryptionPostRules")
+287        self.DecryptionRules = GroupedResources(
+288            self.DecryptionPreRules,
+289            self.DecryptionPostRules,
+290        )
+291        self.TunnelInspectionPreRules = resource("TunnelInspectionPreRules")
+292        self.TunnelInspectionPostRules = resource("TunnelInspectionPostRules")
+293        self.TunnelInspectionRules = GroupedResources(
+294            self.TunnelInspectionPreRules,
+295            self.TunnelInspectionPostRules,
+296        )
+297        self.ApplicationOverridePreRules = resource("ApplicationOverridePreRules")
+298        self.ApplicationOverridePostRules = resource("ApplicationOverridePostRules")
+299        self.ApplicationOverrideRules = GroupedResources(
+300            self.ApplicationOverridePreRules,
+301            self.ApplicationOverridePostRules,
+302        )
+303        self.AuthenticationPreRules = resource("AuthenticationPreRules")
+304        self.AuthenticationPostRules = resource("AuthenticationPostRules")
+305        self.AuthenticationRules = GroupedResources(
+306            self.AuthenticationPreRules,
+307            self.AuthenticationPostRules,
+308        )
+309        self.DoSPreRules = resource("DoSPreRules")
+310        self.DoSPostRules = resource("DoSPostRules")
+311        self.DoSRules = GroupedResources(self.DoSPreRules, self.DoSPostRules)
+312        self.SDWANPreRules = resource("SDWANPreRules")
+313        self.SDWANPostRules = resource("SDWANPostRules")
+314        self.SDWANRules = GroupedResources(self.SDWANPreRules, self.SDWANPostRules)
+315
+316
+317class PanoramaNetworkResourceType(PanoramaResourceType):
+318    """
+319    Represent the 'Network' subsection in the API.
+320    """
+321
+322    DEFAULT_PARAMS: ClassVar = {
+323        "location": "template",
+324    }
+325    resource_type = "Network"
+326
+327    def __init__(self, client, domain, version="v10.1"):
+328        resource_type = self.resource_type
+329        super().__init__(client, resource_type)
+330
+331        def resource(name):
+332            return PanoramaResource(
+333                client,
+334                domain,
+335                resource_type,
+336                name,
+337                version=version,
+338                default_params=self.DEFAULT_PARAMS,
+339            )
+340
+341        self.EthernetInterfaces = resource("EthernetInterfaces")
+342        self.AggregateEthernetInterfaces = resource("AggregateEthernetInterfaces")
+343        self.VLANInterfaces = resource("VLANInterfaces")
+344        self.LoopbackInterfaces = resource("LoopbackInterfaces")
+345        self.TunnelIntefaces = resource("TunnelIntefaces")
+346        self.SDWANInterfaces = resource("SDWANInterfaces")
+347        self.Zones = resource("Zones")
+348        self.VLANs = resource("VLANs")
+349        self.VirtualWires = resource("VirtualWires")
+350        self.VirtualRouters = resource("VirtualRouters")
+351        self.IPSecTunnels = resource("IPSecTunnels")
+352        self.GRETunnels = resource("GRETunnels")
+353        self.DHCPServers = resource("DHCPServers")
+354        self.DHCPRelays = resource("DHCPRelays")
+355        self.DNSProxies = resource("DNSProxies")
+356        self.GlobalProtectPortals = resource("GlobalProtectPortals")
+357        self.GlobalProtectGateways = resource("GlobalProtectGateways")
+358        self.GlobalProtectGatewayAgentTunnels = resource(
+359            "GlobalProtectGatewayAgentTunnels",
+360        )
+361        self.GlobalProtectGatewaySatelliteTunnels = resource(
+362            "GlobalProtectGatewaySatelliteTunnels",
+363        )
+364        self.GlobalProtectGatewayMDMServers = resource("GlobalProtectGatewayMDMServers")
+365        self.GlobalProtectClientlessApps = resource("GlobalProtectClientlessApps")
+366        self.GlobalProtectClientlessAppGroups = resource(
+367            "GlobalProtectClientlessAppGroups",
+368        )
+369        self.QoSInterfaces = resource("QoSInterfaces")
+370        self.LLDP = resource("LLDP")
+371        self.GlobalProtectIPSecCryptoNetworkProfiles = resource(
+372            "GlobalProtectIPSecCryptoNetworkProfiles",
+373        )
+374        self.IKEGatewayNetworkProfiles = resource("IKEGatewayNetworkProfiles")
+375        self.IKECryptoNetworkProfiles = resource("IKECryptoNetworkProfiles")
+376        self.MonitorNetworkProfiles = resource("MonitorNetworkProfiles")
+377        self.InterfaceManagementNetworkProfiles = resource(
+378            "InterfaceManagementNetworkProfiles",
+379        )
+380        self.ZoneProtectionNetworkProfiles = resource("ZoneProtectionNetworkProfiles")
+381        self.QoSNetworkProfiles = resource("QoSNetworkProfiles")
+382        self.LLDPNetworkProfiles = resource("LLDPNetworkProfiles")
+383        self.SDWANInterfaceProfiles = resource("SDWANInterfaceProfiles")
+384
+385
+386class PanoramaDevicesResourceType(PanoramaResourceType):
+387    """
+388    Represent the 'Devices' subsection in the API.
+389    """
+390
+391    DEFAULT_PARAMS: ClassVar = {
+392        "location": "template",
+393    }
+394    resource_type = "Device"
+395
+396    def __init__(self, client, domain, version="v10.1"):
+397        resource_type = self.resource_type
+398        super().__init__(client, resource_type)
+399
+400        def resource(name):
+401            return PanoramaResource(
+402                client,
+403                domain,
+404                resource_type,
+405                name,
+406                version=version,
+407                default_params=self.DEFAULT_PARAMS,
+408            )
+409
+410        self.VirtualSystems = resource("VirtualSystems")
+411
+412
+413__all__ = [
+414    "PanoramaDevicesResourceType",
+415    "PanoramaNetworkResourceType",
+416    "PanoramaObjectsResourceType",
+417    "PanoramaPanoramaResourceType",
+418    "PanoramaPoliciesResourceType",
+419]
+
+ + +
+
+ +
+ + class + PanoramaDevicesResourceType(PanoramaResourceType): + + + +
+ + 
387class PanoramaDevicesResourceType(PanoramaResourceType):
+388    """
+389    Represent the 'Devices' subsection in the API.
+390    """
+391
+392    DEFAULT_PARAMS: ClassVar = {
+393        "location": "template",
+394    }
+395    resource_type = "Device"
+396
+397    def __init__(self, client, domain, version="v10.1"):
+398        resource_type = self.resource_type
+399        super().__init__(client, resource_type)
+400
+401        def resource(name):
+402            return PanoramaResource(
+403                client,
+404                domain,
+405                resource_type,
+406                name,
+407                version=version,
+408                default_params=self.DEFAULT_PARAMS,
+409            )
+410
+411        self.VirtualSystems = resource("VirtualSystems")
+
+ + +

Represent the 'Devices' subsection in the API.

+
+ + +
+ +
+ + PanoramaDevicesResourceType(client, domain, version='v10.1') + + + +
+ + 
397    def __init__(self, client, domain, version="v10.1"):
+398        resource_type = self.resource_type
+399        super().__init__(client, resource_type)
+400
+401        def resource(name):
+402            return PanoramaResource(
+403                client,
+404                domain,
+405                resource_type,
+406                name,
+407                version=version,
+408                default_params=self.DEFAULT_PARAMS,
+409            )
+410
+411        self.VirtualSystems = resource("VirtualSystems")
+
+ + + + +
+
+
+ DEFAULT_PARAMS: ClassVar = +{'location': 'template'} + + +
+ + + + +
+
+
+ resource_type = +'Device' + + +
+ + + + +
+
+
+ VirtualSystems + + +
+ + + + +
+
+
+ +
+ + class + PanoramaNetworkResourceType(PanoramaResourceType): + + + +
+ + 
318class PanoramaNetworkResourceType(PanoramaResourceType):
+319    """
+320    Represent the 'Network' subsection in the API.
+321    """
+322
+323    DEFAULT_PARAMS: ClassVar = {
+324        "location": "template",
+325    }
+326    resource_type = "Network"
+327
+328    def __init__(self, client, domain, version="v10.1"):
+329        resource_type = self.resource_type
+330        super().__init__(client, resource_type)
+331
+332        def resource(name):
+333            return PanoramaResource(
+334                client,
+335                domain,
+336                resource_type,
+337                name,
+338                version=version,
+339                default_params=self.DEFAULT_PARAMS,
+340            )
+341
+342        self.EthernetInterfaces = resource("EthernetInterfaces")
+343        self.AggregateEthernetInterfaces = resource("AggregateEthernetInterfaces")
+344        self.VLANInterfaces = resource("VLANInterfaces")
+345        self.LoopbackInterfaces = resource("LoopbackInterfaces")
+346        self.TunnelIntefaces = resource("TunnelIntefaces")
+347        self.SDWANInterfaces = resource("SDWANInterfaces")
+348        self.Zones = resource("Zones")
+349        self.VLANs = resource("VLANs")
+350        self.VirtualWires = resource("VirtualWires")
+351        self.VirtualRouters = resource("VirtualRouters")
+352        self.IPSecTunnels = resource("IPSecTunnels")
+353        self.GRETunnels = resource("GRETunnels")
+354        self.DHCPServers = resource("DHCPServers")
+355        self.DHCPRelays = resource("DHCPRelays")
+356        self.DNSProxies = resource("DNSProxies")
+357        self.GlobalProtectPortals = resource("GlobalProtectPortals")
+358        self.GlobalProtectGateways = resource("GlobalProtectGateways")
+359        self.GlobalProtectGatewayAgentTunnels = resource(
+360            "GlobalProtectGatewayAgentTunnels",
+361        )
+362        self.GlobalProtectGatewaySatelliteTunnels = resource(
+363            "GlobalProtectGatewaySatelliteTunnels",
+364        )
+365        self.GlobalProtectGatewayMDMServers = resource("GlobalProtectGatewayMDMServers")
+366        self.GlobalProtectClientlessApps = resource("GlobalProtectClientlessApps")
+367        self.GlobalProtectClientlessAppGroups = resource(
+368            "GlobalProtectClientlessAppGroups",
+369        )
+370        self.QoSInterfaces = resource("QoSInterfaces")
+371        self.LLDP = resource("LLDP")
+372        self.GlobalProtectIPSecCryptoNetworkProfiles = resource(
+373            "GlobalProtectIPSecCryptoNetworkProfiles",
+374        )
+375        self.IKEGatewayNetworkProfiles = resource("IKEGatewayNetworkProfiles")
+376        self.IKECryptoNetworkProfiles = resource("IKECryptoNetworkProfiles")
+377        self.MonitorNetworkProfiles = resource("MonitorNetworkProfiles")
+378        self.InterfaceManagementNetworkProfiles = resource(
+379            "InterfaceManagementNetworkProfiles",
+380        )
+381        self.ZoneProtectionNetworkProfiles = resource("ZoneProtectionNetworkProfiles")
+382        self.QoSNetworkProfiles = resource("QoSNetworkProfiles")
+383        self.LLDPNetworkProfiles = resource("LLDPNetworkProfiles")
+384        self.SDWANInterfaceProfiles = resource("SDWANInterfaceProfiles")
+
+ + +

Represent the 'Network' subsection in the API.

+
+ + +
+ +
+ + PanoramaNetworkResourceType(client, domain, version='v10.1') + + + +
+ + 
328    def __init__(self, client, domain, version="v10.1"):
+329        resource_type = self.resource_type
+330        super().__init__(client, resource_type)
+331
+332        def resource(name):
+333            return PanoramaResource(
+334                client,
+335                domain,
+336                resource_type,
+337                name,
+338                version=version,
+339                default_params=self.DEFAULT_PARAMS,
+340            )
+341
+342        self.EthernetInterfaces = resource("EthernetInterfaces")
+343        self.AggregateEthernetInterfaces = resource("AggregateEthernetInterfaces")
+344        self.VLANInterfaces = resource("VLANInterfaces")
+345        self.LoopbackInterfaces = resource("LoopbackInterfaces")
+346        self.TunnelIntefaces = resource("TunnelIntefaces")
+347        self.SDWANInterfaces = resource("SDWANInterfaces")
+348        self.Zones = resource("Zones")
+349        self.VLANs = resource("VLANs")
+350        self.VirtualWires = resource("VirtualWires")
+351        self.VirtualRouters = resource("VirtualRouters")
+352        self.IPSecTunnels = resource("IPSecTunnels")
+353        self.GRETunnels = resource("GRETunnels")
+354        self.DHCPServers = resource("DHCPServers")
+355        self.DHCPRelays = resource("DHCPRelays")
+356        self.DNSProxies = resource("DNSProxies")
+357        self.GlobalProtectPortals = resource("GlobalProtectPortals")
+358        self.GlobalProtectGateways = resource("GlobalProtectGateways")
+359        self.GlobalProtectGatewayAgentTunnels = resource(
+360            "GlobalProtectGatewayAgentTunnels",
+361        )
+362        self.GlobalProtectGatewaySatelliteTunnels = resource(
+363            "GlobalProtectGatewaySatelliteTunnels",
+364        )
+365        self.GlobalProtectGatewayMDMServers = resource("GlobalProtectGatewayMDMServers")
+366        self.GlobalProtectClientlessApps = resource("GlobalProtectClientlessApps")
+367        self.GlobalProtectClientlessAppGroups = resource(
+368            "GlobalProtectClientlessAppGroups",
+369        )
+370        self.QoSInterfaces = resource("QoSInterfaces")
+371        self.LLDP = resource("LLDP")
+372        self.GlobalProtectIPSecCryptoNetworkProfiles = resource(
+373            "GlobalProtectIPSecCryptoNetworkProfiles",
+374        )
+375        self.IKEGatewayNetworkProfiles = resource("IKEGatewayNetworkProfiles")
+376        self.IKECryptoNetworkProfiles = resource("IKECryptoNetworkProfiles")
+377        self.MonitorNetworkProfiles = resource("MonitorNetworkProfiles")
+378        self.InterfaceManagementNetworkProfiles = resource(
+379            "InterfaceManagementNetworkProfiles",
+380        )
+381        self.ZoneProtectionNetworkProfiles = resource("ZoneProtectionNetworkProfiles")
+382        self.QoSNetworkProfiles = resource("QoSNetworkProfiles")
+383        self.LLDPNetworkProfiles = resource("LLDPNetworkProfiles")
+384        self.SDWANInterfaceProfiles = resource("SDWANInterfaceProfiles")
+
+ + + + +
+
+
+ DEFAULT_PARAMS: ClassVar = +{'location': 'template'} + + +
+ + + + +
+
+
+ resource_type = +'Network' + + +
+ + + + +
+
+
+ EthernetInterfaces + + +
+ + + + +
+
+
+ AggregateEthernetInterfaces + + +
+ + + + +
+
+
+ VLANInterfaces + + +
+ + + + +
+
+
+ LoopbackInterfaces + + +
+ + + + +
+
+
+ TunnelIntefaces + + +
+ + + + +
+
+
+ SDWANInterfaces + + +
+ + + + +
+
+
+ Zones + + +
+ + + + +
+
+
+ VLANs + + +
+ + + + +
+
+
+ VirtualWires + + +
+ + + + +
+
+
+ VirtualRouters + + +
+ + + + +
+
+
+ IPSecTunnels + + +
+ + + + +
+
+
+ GRETunnels + + +
+ + + + +
+
+
+ DHCPServers + + +
+ + + + +
+
+
+ DHCPRelays + + +
+ + + + +
+
+
+ DNSProxies + + +
+ + + + +
+
+
+ GlobalProtectPortals + + +
+ + + + +
+
+
+ GlobalProtectGateways + + +
+ + + + +
+
+
+ GlobalProtectGatewayAgentTunnels + + +
+ + + + +
+
+
+ GlobalProtectGatewaySatelliteTunnels + + +
+ + + + +
+
+
+ GlobalProtectGatewayMDMServers + + +
+ + + + +
+
+
+ GlobalProtectClientlessApps + + +
+ + + + +
+
+
+ GlobalProtectClientlessAppGroups + + +
+ + + + +
+
+
+ QoSInterfaces + + +
+ + + + +
+
+
+ LLDP + + +
+ + + + +
+
+
+ GlobalProtectIPSecCryptoNetworkProfiles + + +
+ + + + +
+
+
+ IKEGatewayNetworkProfiles + + +
+ + + + +
+
+
+ IKECryptoNetworkProfiles + + +
+ + + + +
+
+
+ MonitorNetworkProfiles + + +
+ + + + +
+
+
+ InterfaceManagementNetworkProfiles + + +
+ + + + +
+
+
+ ZoneProtectionNetworkProfiles + + +
+ + + + +
+
+
+ QoSNetworkProfiles + + +
+ + + + +
+
+
+ LLDPNetworkProfiles + + +
+ + + + +
+
+
+ SDWANInterfaceProfiles + + +
+ + + + +
+
+
+ +
+ + class + PanoramaObjectsResourceType(PanoramaResourceType): + + + +
+ + 
188class PanoramaObjectsResourceType(PanoramaResourceType):
+189    """
+190    Represent the 'Objects' subsection in the API.
+191    """
+192
+193    resource_type = "Objects"
+194
+195    def __init__(self, client, domain, version="v10.1"):
+196        resource_type = self.resource_type
+197        super().__init__(client, resource_type)
+198
+199        def resource(name):
+200            return PanoramaResource(
+201                client,
+202                domain,
+203                resource_type,
+204                name,
+205                version=version,
+206            )
+207
+208        self.Addresses = resource("Addresses")
+209        self.AddressGroups = resource("AddressGroups")
+210        self.Regions = resource("Regions")
+211        self.Applications = resource("Applications")
+212        self.ApplicationGroups = resource("ApplicationGroups")
+213        self.ApplicationFilters = resource("ApplicationFilters")
+214        self.Services = resource("Services")
+215        self.ServiceGroups = resource("ServiceGroups")
+216        self.Tags = resource("Tags")
+217        self.GlobalProtectHIPObjects = resource("GlobalProtectHIPObjects")
+218        self.GlobalProtectHIPProfiles = resource("GlobalProtectHIPProfiles")
+219        self.ExternalDynamicLists = resource("ExternalDynamicLists")
+220        self.CustomDataPatterns = resource("CustomDataPatterns")
+221        self.CustomSpywareSignatures = resource("CustomSpywareSignatures")
+222        self.CustomVulnerabilitySignatures = resource("CustomVulnerabilitySignatures")
+223        self.CustomURLCategories = resource("CustomURLCategories")
+224        self.AntivirusSecurityProfiles = resource("AntivirusSecurityProfiles")
+225        self.AntiSpywareSecurityProfiles = resource("AntiSpywareSecurityProfiles")
+226        self.VulnerabilityProtectionSecurityProfiles = resource(
+227            "VulnerabilityProtectionSecurityProfiles",
+228        )
+229        self.URLFilteringSecurityProfiles = resource("URLFilteringSecurityProfiles")
+230        self.FileBlockingSecurityProfiles = resource("FileBlockingSecurityProfiles")
+231        self.WildFireAnalysisSecurityProfiles = resource(
+232            "WildFireAnalysisSecurityProfiles",
+233        )
+234        self.DataFilteringSecurityProfiles = resource("DataFilteringSecurityProfiles")
+235        self.DoSProtectionSecurityProfiles = resource("DoSProtectionSecurityProfiles")
+236        self.SecurityProfileGroups = resource("SecurityProfileGroups")
+237        self.LogForwardingProfiles = resource("LogForwardingProfiles")
+238        self.AuthenticationEnforcements = resource("AuthenticationEnforcements")
+239        self.DecryptionProfiles = resource("DecryptionProfiles")
+240        self.DecryptionForwardingProfiles = resource("DecryptionForwardingProfiles")
+241        self.Schedules = resource("Schedules")
+242        self.SDWANPathQualityProfiles = resource("SDWANPathQualityProfiles")
+243        self.SDWANTrafficDistributionProfiles = resource(
+244            "SDWANTrafficDistributionProfiles",
+245        )
+
+ + +

Represent the 'Objects' subsection in the API.

+
+ + +
+ +
+ + PanoramaObjectsResourceType(client, domain, version='v10.1') + + + +
+ + 
195    def __init__(self, client, domain, version="v10.1"):
+196        resource_type = self.resource_type
+197        super().__init__(client, resource_type)
+198
+199        def resource(name):
+200            return PanoramaResource(
+201                client,
+202                domain,
+203                resource_type,
+204                name,
+205                version=version,
+206            )
+207
+208        self.Addresses = resource("Addresses")
+209        self.AddressGroups = resource("AddressGroups")
+210        self.Regions = resource("Regions")
+211        self.Applications = resource("Applications")
+212        self.ApplicationGroups = resource("ApplicationGroups")
+213        self.ApplicationFilters = resource("ApplicationFilters")
+214        self.Services = resource("Services")
+215        self.ServiceGroups = resource("ServiceGroups")
+216        self.Tags = resource("Tags")
+217        self.GlobalProtectHIPObjects = resource("GlobalProtectHIPObjects")
+218        self.GlobalProtectHIPProfiles = resource("GlobalProtectHIPProfiles")
+219        self.ExternalDynamicLists = resource("ExternalDynamicLists")
+220        self.CustomDataPatterns = resource("CustomDataPatterns")
+221        self.CustomSpywareSignatures = resource("CustomSpywareSignatures")
+222        self.CustomVulnerabilitySignatures = resource("CustomVulnerabilitySignatures")
+223        self.CustomURLCategories = resource("CustomURLCategories")
+224        self.AntivirusSecurityProfiles = resource("AntivirusSecurityProfiles")
+225        self.AntiSpywareSecurityProfiles = resource("AntiSpywareSecurityProfiles")
+226        self.VulnerabilityProtectionSecurityProfiles = resource(
+227            "VulnerabilityProtectionSecurityProfiles",
+228        )
+229        self.URLFilteringSecurityProfiles = resource("URLFilteringSecurityProfiles")
+230        self.FileBlockingSecurityProfiles = resource("FileBlockingSecurityProfiles")
+231        self.WildFireAnalysisSecurityProfiles = resource(
+232            "WildFireAnalysisSecurityProfiles",
+233        )
+234        self.DataFilteringSecurityProfiles = resource("DataFilteringSecurityProfiles")
+235        self.DoSProtectionSecurityProfiles = resource("DoSProtectionSecurityProfiles")
+236        self.SecurityProfileGroups = resource("SecurityProfileGroups")
+237        self.LogForwardingProfiles = resource("LogForwardingProfiles")
+238        self.AuthenticationEnforcements = resource("AuthenticationEnforcements")
+239        self.DecryptionProfiles = resource("DecryptionProfiles")
+240        self.DecryptionForwardingProfiles = resource("DecryptionForwardingProfiles")
+241        self.Schedules = resource("Schedules")
+242        self.SDWANPathQualityProfiles = resource("SDWANPathQualityProfiles")
+243        self.SDWANTrafficDistributionProfiles = resource(
+244            "SDWANTrafficDistributionProfiles",
+245        )
+
+ + + + +
+
+
+ resource_type = +'Objects' + + +
+ + + + +
+
+
+ Addresses + + +
+ + + + +
+
+
+ AddressGroups + + +
+ + + + +
+
+
+ Regions + + +
+ + + + +
+
+
+ Applications + + +
+ + + + +
+
+
+ ApplicationGroups + + +
+ + + + +
+
+
+ ApplicationFilters + + +
+ + + + +
+
+
+ Services + + +
+ + + + +
+
+
+ ServiceGroups + + +
+ + + + +
+
+
+ Tags + + +
+ + + + +
+
+
+ GlobalProtectHIPObjects + + +
+ + + + +
+
+
+ GlobalProtectHIPProfiles + + +
+ + + + +
+
+
+ ExternalDynamicLists + + +
+ + + + +
+
+
+ CustomDataPatterns + + +
+ + + + +
+
+
+ CustomSpywareSignatures + + +
+ + + + +
+
+
+ CustomVulnerabilitySignatures + + +
+ + + + +
+
+
+ CustomURLCategories + + +
+ + + + +
+
+
+ AntivirusSecurityProfiles + + +
+ + + + +
+
+
+ AntiSpywareSecurityProfiles + + +
+ + + + +
+
+
+ VulnerabilityProtectionSecurityProfiles + + +
+ + + + +
+
+
+ URLFilteringSecurityProfiles + + +
+ + + + +
+
+
+ FileBlockingSecurityProfiles + + +
+ + + + +
+
+
+ WildFireAnalysisSecurityProfiles + + +
+ + + + +
+
+
+ DataFilteringSecurityProfiles + + +
+ + + + +
+
+
+ DoSProtectionSecurityProfiles + + +
+ + + + +
+
+
+ SecurityProfileGroups + + +
+ + + + +
+
+
+ LogForwardingProfiles + + +
+ + + + +
+
+
+ AuthenticationEnforcements + + +
+ + + + +
+
+
+ DecryptionProfiles + + +
+ + + + +
+
+
+ DecryptionForwardingProfiles + + +
+ + + + +
+
+
+ Schedules + + +
+ + + + +
+
+
+ SDWANPathQualityProfiles + + +
+ + + + +
+
+
+ SDWANTrafficDistributionProfiles + + +
+ + + + +
+
+
+ +
+ + class + PanoramaPanoramaResourceType(PanoramaResourceType): + + + +
+ + 
169class PanoramaPanoramaResourceType(PanoramaResourceType):
+170    resource_type = "Panorama"
+171
+172    def __init__(self, client, domain, version="v10.1"):
+173        resource_type = self.resource_type
+174        super().__init__(client, resource_type)
+175
+176        def resource(name):
+177            return BasePanoramaResource(
+178                client,
+179                domain,
+180                resource_type,
+181                name,
+182                version=version,
+183            )
+184
+185        self.DeviceGroups = resource("DeviceGroups")
+
+ + + + +
+ +
+ + PanoramaPanoramaResourceType(client, domain, version='v10.1') + + + +
+ + 
172    def __init__(self, client, domain, version="v10.1"):
+173        resource_type = self.resource_type
+174        super().__init__(client, resource_type)
+175
+176        def resource(name):
+177            return BasePanoramaResource(
+178                client,
+179                domain,
+180                resource_type,
+181                name,
+182                version=version,
+183            )
+184
+185        self.DeviceGroups = resource("DeviceGroups")
+
+ + + + +
+
+
+ resource_type = +'Panorama' + + +
+ + + + +
+
+
+ DeviceGroups + + +
+ + + + +
+
+
+ +
+ + class + PanoramaPoliciesResourceType(PanoramaResourceType): + + + +
+ + 
248class PanoramaPoliciesResourceType(PanoramaResourceType):
+249    """
+250    Represent the 'Policies' subsection in the API.
+251    """
+252
+253    resource_type = "Policies"
+254
+255    def __init__(self, client, domain, version="v10.1"):
+256        resource_type = self.resource_type
+257        super().__init__(client, resource_type)
+258
+259        def resource(name):
+260            return PanoramaResource(
+261                client,
+262                domain,  # host
+263                resource_type,
+264                name,
+265                version=version,
+266            )
+267
+268        self.SecurityPreRules = resource("SecurityPreRules")
+269        self.SecurityPostRules = resource("SecurityPostRules")
+270        self.SecurityRules = GroupedResources(
+271            self.SecurityPreRules,
+272            self.SecurityPostRules,
+273        )
+274        self.NATPreRules = resource("NATPreRules")
+275        self.NATPostRules = resource("NATPostRules")
+276        self.NATRules = GroupedResources(self.NATPreRules, self.NATPostRules)
+277        self.QoSPreRules = resource("QoSPreRules")
+278        self.QoSPostRules = resource("QoSPostRules")
+279        self.QoSRules = GroupedResources(self.QoSPreRules, self.QoSPostRules)
+280        self.PolicyBasedForwardingPreRules = resource("PolicyBasedForwardingPreRules")
+281        self.PolicyBasedForwardingPostRules = resource("PolicyBasedForwardingPostRules")
+282        self.PolicyBasedForwardingRules = GroupedResources(
+283            self.PolicyBasedForwardingPreRules,
+284            self.PolicyBasedForwardingPostRules,
+285        )
+286        self.DecryptionPreRules = resource("DecryptionPreRules")
+287        self.DecryptionPostRules = resource("DecryptionPostRules")
+288        self.DecryptionRules = GroupedResources(
+289            self.DecryptionPreRules,
+290            self.DecryptionPostRules,
+291        )
+292        self.TunnelInspectionPreRules = resource("TunnelInspectionPreRules")
+293        self.TunnelInspectionPostRules = resource("TunnelInspectionPostRules")
+294        self.TunnelInspectionRules = GroupedResources(
+295            self.TunnelInspectionPreRules,
+296            self.TunnelInspectionPostRules,
+297        )
+298        self.ApplicationOverridePreRules = resource("ApplicationOverridePreRules")
+299        self.ApplicationOverridePostRules = resource("ApplicationOverridePostRules")
+300        self.ApplicationOverrideRules = GroupedResources(
+301            self.ApplicationOverridePreRules,
+302            self.ApplicationOverridePostRules,
+303        )
+304        self.AuthenticationPreRules = resource("AuthenticationPreRules")
+305        self.AuthenticationPostRules = resource("AuthenticationPostRules")
+306        self.AuthenticationRules = GroupedResources(
+307            self.AuthenticationPreRules,
+308            self.AuthenticationPostRules,
+309        )
+310        self.DoSPreRules = resource("DoSPreRules")
+311        self.DoSPostRules = resource("DoSPostRules")
+312        self.DoSRules = GroupedResources(self.DoSPreRules, self.DoSPostRules)
+313        self.SDWANPreRules = resource("SDWANPreRules")
+314        self.SDWANPostRules = resource("SDWANPostRules")
+315        self.SDWANRules = GroupedResources(self.SDWANPreRules, self.SDWANPostRules)
+
+ + +

Represent the 'Policies' subsection in the API.

+
+ + +
+ +
+ + PanoramaPoliciesResourceType(client, domain, version='v10.1') + + + +
+ + 
255    def __init__(self, client, domain, version="v10.1"):
+256        resource_type = self.resource_type
+257        super().__init__(client, resource_type)
+258
+259        def resource(name):
+260            return PanoramaResource(
+261                client,
+262                domain,  # host
+263                resource_type,
+264                name,
+265                version=version,
+266            )
+267
+268        self.SecurityPreRules = resource("SecurityPreRules")
+269        self.SecurityPostRules = resource("SecurityPostRules")
+270        self.SecurityRules = GroupedResources(
+271            self.SecurityPreRules,
+272            self.SecurityPostRules,
+273        )
+274        self.NATPreRules = resource("NATPreRules")
+275        self.NATPostRules = resource("NATPostRules")
+276        self.NATRules = GroupedResources(self.NATPreRules, self.NATPostRules)
+277        self.QoSPreRules = resource("QoSPreRules")
+278        self.QoSPostRules = resource("QoSPostRules")
+279        self.QoSRules = GroupedResources(self.QoSPreRules, self.QoSPostRules)
+280        self.PolicyBasedForwardingPreRules = resource("PolicyBasedForwardingPreRules")
+281        self.PolicyBasedForwardingPostRules = resource("PolicyBasedForwardingPostRules")
+282        self.PolicyBasedForwardingRules = GroupedResources(
+283            self.PolicyBasedForwardingPreRules,
+284            self.PolicyBasedForwardingPostRules,
+285        )
+286        self.DecryptionPreRules = resource("DecryptionPreRules")
+287        self.DecryptionPostRules = resource("DecryptionPostRules")
+288        self.DecryptionRules = GroupedResources(
+289            self.DecryptionPreRules,
+290            self.DecryptionPostRules,
+291        )
+292        self.TunnelInspectionPreRules = resource("TunnelInspectionPreRules")
+293        self.TunnelInspectionPostRules = resource("TunnelInspectionPostRules")
+294        self.TunnelInspectionRules = GroupedResources(
+295            self.TunnelInspectionPreRules,
+296            self.TunnelInspectionPostRules,
+297        )
+298        self.ApplicationOverridePreRules = resource("ApplicationOverridePreRules")
+299        self.ApplicationOverridePostRules = resource("ApplicationOverridePostRules")
+300        self.ApplicationOverrideRules = GroupedResources(
+301            self.ApplicationOverridePreRules,
+302            self.ApplicationOverridePostRules,
+303        )
+304        self.AuthenticationPreRules = resource("AuthenticationPreRules")
+305        self.AuthenticationPostRules = resource("AuthenticationPostRules")
+306        self.AuthenticationRules = GroupedResources(
+307            self.AuthenticationPreRules,
+308            self.AuthenticationPostRules,
+309        )
+310        self.DoSPreRules = resource("DoSPreRules")
+311        self.DoSPostRules = resource("DoSPostRules")
+312        self.DoSRules = GroupedResources(self.DoSPreRules, self.DoSPostRules)
+313        self.SDWANPreRules = resource("SDWANPreRules")
+314        self.SDWANPostRules = resource("SDWANPostRules")
+315        self.SDWANRules = GroupedResources(self.SDWANPreRules, self.SDWANPostRules)
+
+ + + + +
+
+
+ resource_type = +'Policies' + + +
+ + + + +
+
+
+ SecurityPreRules + + +
+ + + + +
+
+
+ SecurityPostRules + + +
+ + + + +
+
+
+ SecurityRules + + +
+ + + + +
+
+
+ NATPreRules + + +
+ + + + +
+
+
+ NATPostRules + + +
+ + + + +
+
+
+ NATRules + + +
+ + + + +
+
+
+ QoSPreRules + + +
+ + + + +
+
+
+ QoSPostRules + + +
+ + + + +
+
+
+ QoSRules + + +
+ + + + +
+
+
+ PolicyBasedForwardingPreRules + + +
+ + + + +
+
+
+ PolicyBasedForwardingPostRules + + +
+ + + + +
+
+
+ PolicyBasedForwardingRules + + +
+ + + + +
+
+
+ DecryptionPreRules + + +
+ + + + +
+
+
+ DecryptionPostRules + + +
+ + + + +
+
+
+ DecryptionRules + + +
+ + + + +
+
+
+ TunnelInspectionPreRules + + +
+ + + + +
+
+
+ TunnelInspectionPostRules + + +
+ + + + +
+
+
+ TunnelInspectionRules + + +
+ + + + +
+
+
+ ApplicationOverridePreRules + + +
+ + + + +
+
+
+ ApplicationOverridePostRules + + +
+ + + + +
+
+
+ ApplicationOverrideRules + + +
+ + + + +
+
+
+ AuthenticationPreRules + + +
+ + + + +
+
+
+ AuthenticationPostRules + + +
+ + + + +
+
+
+ AuthenticationRules + + +
+ + + + +
+
+
+ DoSPreRules + + +
+ + + + +
+
+
+ DoSPostRules + + +
+ + + + +
+
+
+ DoSRules + + +
+ + + + +
+
+
+ SDWANPreRules + + +
+ + + + +
+
+
+ SDWANPostRules + + +
+ + + + +
+
+
+ SDWANRules + + +
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/restapi/restapi.html b/public/pa_api/restapi/restapi.html new file mode 100644 index 0000000..5b1dc4e --- /dev/null +++ b/public/pa_api/restapi/restapi.html @@ -0,0 +1,739 @@ + + + + + + + pa_api.restapi.restapi API documentation + + + + + + + + + +
+
+

+pa_api.restapi.restapi

+ + + + + + + 
  1import json
+  2import logging
+  3from itertools import chain
+  4
+  5import requests
+  6
+  7# Remove warning for unverified certificate
+  8# https://stackoverflow.com/questions/27981545/suppress-insecurerequestwarning-unverified-https-request-is-being-made-in-pytho
+  9from requests.packages.urllib3.exceptions import InsecureRequestWarning
+ 10
+ 11from pa_api.constants import PANORAMA_ERRORS, SUCCESS_CODE
+ 12from pa_api.utils import clean_url_host
+ 13
+ 14from .rest_resources import (
+ 15    PanoramaDevicesResourceType,
+ 16    PanoramaNetworkResourceType,
+ 17    PanoramaObjectsResourceType,
+ 18    PanoramaPanoramaResourceType,
+ 19    PanoramaPoliciesResourceType,
+ 20)
+ 21
+ 22requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
+ 23
+ 24OBJECT_RESOURCES = [
+ 25    "Addresses",
+ 26    "AddressGroups",
+ 27    "Regions",
+ 28    "Applications",
+ 29    "ApplicationGroups",
+ 30    "ApplicationFilters",
+ 31    "Services",
+ 32    "ServiceGroups",
+ 33    "Tags",
+ 34    "GlobalProtectHIPObjects",
+ 35    "GlobalProtectHIPProfiles",
+ 36    "ExternalDynamicLists",
+ 37    "CustomDataPatterns",
+ 38    "CustomSpywareSignatures",
+ 39    "CustomVulnerabilitySignatures",
+ 40    "CustomURLCategories",
+ 41    "AntivirusSecurityProfiles",
+ 42    "AntiSpywareSecurityProfiles",
+ 43    "VulnerabilityProtectionSecurityProfiles",
+ 44    "URLFilteringSecurityProfiles",
+ 45    "FileBlockingSecurityProfiles",
+ 46    "WildFireAnalysisSecurityProfiles",
+ 47    "DataFilteringSecurityProfiles",
+ 48    "DoSProtectionSecurityProfiles",
+ 49    "SecurityProfileGroups",
+ 50    "LogForwardingProfiles",
+ 51    "AuthenticationEnforcements",
+ 52    "DecryptionProfiles",
+ 53    "DecryptionForwardingProfiles",
+ 54    "Schedules",
+ 55    "SDWANPathQualityProfiles",
+ 56    "SDWANTrafficDistributionProfiles",
+ 57]
+ 58
+ 59POLICY_RESOURCES = [
+ 60    "SecurityRules",
+ 61    "NATRules",
+ 62    "QoSRules",
+ 63    "PolicyBasedForwardingRules",
+ 64    "DecryptionRules",
+ 65    "TunnelInspectionRules",
+ 66    "ApplicationOverrideRules",
+ 67    "AuthenticationRules",
+ 68    "DoSRules",
+ 69    "SDWANRules",
+ 70]
+ 71
+ 72NETWORK_RESOURCES = [
+ 73    "EthernetInterfaces",
+ 74    "AggregateEthernetInterfaces",
+ 75    "VLANInterfaces",
+ 76    "LoopbackInterfaces",
+ 77    "TunnelIntefaces",
+ 78    "SDWANInterfaces",
+ 79    "Zones",
+ 80    "VLANs",
+ 81    "VirtualWires",
+ 82    "VirtualRouters",
+ 83    "IPSecTunnels",
+ 84    "GRETunnels",
+ 85    "DHCPServers",
+ 86    "DHCPRelays",
+ 87    "DNSProxies",
+ 88    "GlobalProtectPortals",
+ 89    "GlobalProtectGateways",
+ 90    "GlobalProtectGatewayAgentTunnels",
+ 91    "GlobalProtectGatewaySatelliteTunnels",
+ 92    "GlobalProtectGatewayMDMServers",
+ 93    "GlobalProtectClientlessApps",
+ 94    "GlobalProtectClientlessAppGroups",
+ 95    "QoSInterfaces",
+ 96    "LLDP",
+ 97    "GlobalProtectIPSecCryptoNetworkProfiles",
+ 98    "IKEGatewayNetworkProfiles",
+ 99    "IKECryptoNetworkProfiles",
+100    "MonitorNetworkProfiles",
+101    "InterfaceManagementNetworkProfiles",
+102    "ZoneProtectionNetworkProfiles",
+103    "QoSNetworkProfiles",
+104    "LLDPNetworkProfiles",
+105    "SDWANInterfaceProfiles",
+106]
+107
+108DEVICE_RESOURCES = [
+109    "VirtualSystems",
+110]
+111
+112DEFAULT_PARAMS = {
+113    "output-format": "json",
+114}
+115
+116
+117class PanoramaAPI:
+118    def __init__(self, api_key=None, verbose=False, verify=False, logger=None):
+119        self._verbose = verbose
+120        self._verify = verify
+121        self._api_key = api_key
+122        self.logger = logger or logging
+123
+124    def _inner_request(
+125        self,
+126        method,
+127        url,
+128        params=None,
+129        headers=None,
+130        data=None,
+131        verify=None,
+132    ):
+133        if params is None:
+134            params = {}
+135        if headers is None:
+136            headers = {}
+137        if verify is None:
+138            verify = self._verify
+139        default_headers = {
+140            "X-PAN-KEY": self._api_key,
+141            # 'Accept': 'application/json, application/xml',
+142            # 'Content-Type': 'application/json'
+143        }
+144        headers = {**default_headers, **headers}
+145        params = {**DEFAULT_PARAMS, **params}
+146        res = requests.request(
+147            method,
+148            url,
+149            params=params,
+150            headers=headers,
+151            verify=verify,
+152        )
+153        # The API always returns a json, no matter what
+154        # if not res.ok:
+155        #     return None
+156        try:
+157            data = res.json()
+158            code = int(
+159                data.get("@code") or data.get("code") or SUCCESS_CODE,
+160            )  # Sometimes, the code is a string, some other times it is a int
+161            status = data.get("@status", "")
+162            success = status == "success"
+163            error_occured = (
+164                not res.ok
+165                or (
+166                    not success and code < SUCCESS_CODE
+167                )  # In case of success, the value 19 is used
+168            )
+169            if not error_occured:
+170                return data, None
+171            message = (
+172                data.get("message")
+173                or PANORAMA_ERRORS.get(data["@code"])
+174                or "Something happened: " + json.dumps(data)
+175            )
+176            error = f"(CODE: {code}) {message}"
+177            if self._verbose:
+178                causes = list(
+179                    chain(
+180                        *(
+181                            details.get("causes", {})
+182                            for details in data.get("details", [])
+183                        ),
+184                    ),
+185                )
+186                details = "".join(c.get("description") for c in causes)
+187                error = f"{error} {details}"
+188            return data, error
+189        except Exception as e:
+190            return None, str(e)
+191
+192    def _request(
+193        self,
+194        method,
+195        url,
+196        params=None,
+197        headers=None,
+198        data=None,
+199        verify=None,
+200        no_exception=False,
+201    ):
+202        data, error = (
+203            self._inner_request(
+204                method,
+205                url,
+206                params=params,
+207                headers=headers,
+208                data=data,
+209                verify=verify,
+210            )
+211            or {}
+212        )
+213        if error:
+214            if no_exception:
+215                self.logger.error(f"Could not {method.lower()} {url}: {error}")
+216                return data, error
+217            raise Exception(error)
+218        data = data.get("result", {}).get("entry") or []
+219        return data, error
+220
+221    def request(self, method, url, params=None, headers=None, data=None, verify=None):
+222        data, _ = (
+223            self._request(
+224                method,
+225                url,
+226                params=params,
+227                headers=headers,
+228                data=data,
+229                verify=verify,
+230            )
+231            or {}
+232        )
+233        return data
+234
+235    def get(self, url, params=None, headers=None, data=None, verify=None):
+236        data, _ = (
+237            self._request(
+238                "GET",
+239                url,
+240                params=params,
+241                headers=headers,
+242                data=data,
+243                verify=verify,
+244            )
+245            or {}
+246        )
+247        return data
+248        # return data.get("result", {}).get("entry") or []
+249
+250    def delete(self, url, params=None, headers=None, data=None, verify=None):
+251        data, _ = (
+252            self._request(
+253                "DELETE",
+254                url,
+255                params=params,
+256                headers=headers,
+257                data=data,
+258                verify=verify,
+259            )
+260            or {}
+261        )
+262        return data
+263
+264
+265class PanoramaClient:
+266    """
+267    Wrapper for the PaloAlto REST API
+268    Resources (e.g. Addresses, Tags, ..) are grouped under their resource types.
+269    See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4
+270
+271    Attributes:
+272
+273        - objects: groups all the objects (Address, Tag, Service, ...)
+274        - policies: groups all the policies (Security, NAT, ...)
+275        - network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)
+276        - device: groups all device-related resources (only VirtualSystems)
+277        - panorama: groups all panorama-management-related resources (only DeviceGroups)
+278    """
+279
+280    objects: PanoramaObjectsResourceType
+281    policies: PanoramaPoliciesResourceType
+282    network: PanoramaNetworkResourceType
+283    device: PanoramaDevicesResourceType
+284    panorama: PanoramaPanoramaResourceType
+285
+286    def __init__(
+287        self,
+288        domain,
+289        api_key=None,
+290        version="v10.1",
+291        verify=False,
+292        verbose=False,
+293    ):
+294        domain, _, _ = clean_url_host(domain)
+295        client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify)
+296        self.client = client
+297        self.objects = PanoramaObjectsResourceType(client, domain, version=version)
+298        self.policies = PanoramaPoliciesResourceType(client, domain, version=version)
+299        self.network = PanoramaNetworkResourceType(client, domain, version=version)
+300        self.device = PanoramaDevicesResourceType(client, domain, version=version)
+301        self.panorama = PanoramaPanoramaResourceType(client, domain, version=version)
+302
+303
+304__all__ = [
+305    "PanoramaClient",
+306]
+
+ + +
+
+ +
+ + class + PanoramaClient: + + + +
+ + 
266class PanoramaClient:
+267    """
+268    Wrapper for the PaloAlto REST API
+269    Resources (e.g. Addresses, Tags, ..) are grouped under their resource types.
+270    See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4
+271
+272    Attributes:
+273
+274        - objects: groups all the objects (Address, Tag, Service, ...)
+275        - policies: groups all the policies (Security, NAT, ...)
+276        - network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)
+277        - device: groups all device-related resources (only VirtualSystems)
+278        - panorama: groups all panorama-management-related resources (only DeviceGroups)
+279    """
+280
+281    objects: PanoramaObjectsResourceType
+282    policies: PanoramaPoliciesResourceType
+283    network: PanoramaNetworkResourceType
+284    device: PanoramaDevicesResourceType
+285    panorama: PanoramaPanoramaResourceType
+286
+287    def __init__(
+288        self,
+289        domain,
+290        api_key=None,
+291        version="v10.1",
+292        verify=False,
+293        verbose=False,
+294    ):
+295        domain, _, _ = clean_url_host(domain)
+296        client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify)
+297        self.client = client
+298        self.objects = PanoramaObjectsResourceType(client, domain, version=version)
+299        self.policies = PanoramaPoliciesResourceType(client, domain, version=version)
+300        self.network = PanoramaNetworkResourceType(client, domain, version=version)
+301        self.device = PanoramaDevicesResourceType(client, domain, version=version)
+302        self.panorama = PanoramaPanoramaResourceType(client, domain, version=version)
+
+ + +

Wrapper for the PaloAlto REST API +Resources (e.g. Addresses, Tags, ..) are grouped under their resource types. +See https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4

+ +

Attributes:

+ +
- objects: groups all the objects (Address, Tag, Service, ...)
+- policies: groups all the policies (Security, NAT, ...)
+- network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)
+- device: groups all device-related resources (only VirtualSystems)
+- panorama: groups all panorama-management-related resources (only DeviceGroups)
+
+
+ + +
+ +
+ + PanoramaClient(domain, api_key=None, version='v10.1', verify=False, verbose=False) + + + +
+ + 
287    def __init__(
+288        self,
+289        domain,
+290        api_key=None,
+291        version="v10.1",
+292        verify=False,
+293        verbose=False,
+294    ):
+295        domain, _, _ = clean_url_host(domain)
+296        client = PanoramaAPI(api_key=api_key, verbose=verbose, verify=verify)
+297        self.client = client
+298        self.objects = PanoramaObjectsResourceType(client, domain, version=version)
+299        self.policies = PanoramaPoliciesResourceType(client, domain, version=version)
+300        self.network = PanoramaNetworkResourceType(client, domain, version=version)
+301        self.device = PanoramaDevicesResourceType(client, domain, version=version)
+302        self.panorama = PanoramaPanoramaResourceType(client, domain, version=version)
+
+ + + + +
+ + + + + +
+
+ client + + +
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi.html b/public/pa_api/xmlapi.html new file mode 100644 index 0000000..963dc6a --- /dev/null +++ b/public/pa_api/xmlapi.html @@ -0,0 +1,3461 @@ + + + + + + + pa_api.xmlapi API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi

+ + + + + + + 
1from . import types
+2from .client import XMLApi
+3
+4__all__ = [
+5    "XMLApi",
+6    "types",
+7]
+
+ + +
+
+ +
+ + class + XMLApi: + + + +
+ + 
  20class XMLApi:
+  21    def __init__(
+  22        self,
+  23        host=None,
+  24        api_key=None,
+  25        ispanorama=None,
+  26        verify=False,
+  27        timeout=None,
+  28        logger=None,
+  29    ):
+  30        env_host, env_apikey = get_credentials_from_env()
+  31        host = host or env_host
+  32        api_key = api_key or env_apikey
+  33        if not host:
+  34            raise Exception("Missing Host")
+  35        if not api_key:
+  36            raise Exception("Missing API Key")
+  37        host, _, _ = clean_url_host(host)
+  38
+  39        self._host = host
+  40        self._api_key = api_key
+  41        self._url = f"{host}/api"
+  42        self._verify = verify
+  43        self._timeout = timeout
+  44        self._ispanorama = ispanorama
+  45        self.logger = logger or logging
+  46
+  47    def _request(
+  48        self,
+  49        type,
+  50        method="GET",
+  51        vsys=None,
+  52        params=None,
+  53        remove_blank_text=True,
+  54        verify=None,
+  55        parse=True,
+  56        stream=None,
+  57        timeout=None,
+  58    ):
+  59        if verify is None:
+  60            verify = self._verify
+  61        if timeout is None:
+  62            timeout = self._timeout
+  63        headers = {"X-PAN-KEY": self._api_key}
+  64        return raw_request(
+  65            self._url,
+  66            type,
+  67            method,
+  68            vsys=vsys,
+  69            params=params,
+  70            headers=headers,
+  71            remove_blank_text=remove_blank_text,
+  72            verify=verify,
+  73            logger=self.logger,
+  74            parse=parse,
+  75            stream=stream,
+  76            timeout=timeout,
+  77        )
+  78
+  79    # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/export-files-api
+  80    # https://knowledgebase.paloaltonetworks.com/KCSArticleDetail?id=kA10g000000ClaOCAS#:~:text=From%20the%20GUI%2C%20go%20to%20Device%20%3E%20Setup,%3E%20scp%20export%20configuration%20%5Btab%20for%20command%20help%5D
+  81    def _export_request(
+  82        self,
+  83        category,
+  84        method="GET",
+  85        params=None,
+  86        verify=None,
+  87        stream=None,
+  88        timeout=None,
+  89    ):
+  90        if params is None:
+  91            params = {}
+  92        params = {"category": category, **params}
+  93        return self._request(
+  94            "export",
+  95            method=method,
+  96            params=params,
+  97            verify=verify,
+  98            parse=False,
+  99            stream=stream,
+ 100            timeout=timeout,
+ 101        ).content
+ 102
+ 103    def export_configuration(
+ 104        self,
+ 105        verify=None,
+ 106        timeout=None,
+ 107    ) -> Element:
+ 108        return self._export_request(
+ 109            category="configuration",
+ 110            verify=verify,
+ 111            timeout=timeout,
+ 112        )
+ 113
+ 114    def export_device_state(
+ 115        self,
+ 116        verify=None,
+ 117        timeout=None,
+ 118    ) -> Element:
+ 119        return self._export_request(
+ 120            category="device-state",
+ 121            verify=verify,
+ 122            timeout=timeout,
+ 123        )
+ 124
+ 125    def _conf_request(
+ 126        self,
+ 127        xpath,
+ 128        action="get",
+ 129        method="GET",
+ 130        vsys=None,
+ 131        params=None,
+ 132        remove_blank_text=True,
+ 133        verify=None,
+ 134        timeout=None,
+ 135    ) -> Element:
+ 136        if params is None:
+ 137            params = {}
+ 138        params = {"action": action, "xpath": xpath, **params}
+ 139        return self._request(
+ 140            "config",
+ 141            method=method,
+ 142            vsys=vsys,
+ 143            params=params,
+ 144            remove_blank_text=remove_blank_text,
+ 145            verify=verify,
+ 146            timeout=timeout,
+ 147        )
+ 148
+ 149    def _op_request(
+ 150        self,
+ 151        cmd,
+ 152        method="POST",
+ 153        vsys=None,
+ 154        params=None,
+ 155        remove_blank_text=True,
+ 156        verify=None,
+ 157        timeout=None,
+ 158    ) -> Element:
+ 159        if params is None:
+ 160            params = {}
+ 161        params = {"cmd": cmd, **params}
+ 162        return self._request(
+ 163            "op",
+ 164            method=method,
+ 165            vsys=vsys,
+ 166            params=params,
+ 167            remove_blank_text=remove_blank_text,
+ 168            verify=verify,
+ 169            timeout=timeout,
+ 170        )
+ 171
+ 172    def _commit_request(
+ 173        self,
+ 174        cmd,
+ 175        method="POST",
+ 176        params=None,
+ 177        remove_blank_text=True,
+ 178        verify=None,
+ 179        timeout=None,
+ 180    ):
+ 181        if params is None:
+ 182            params = {}
+ 183        params = {"cmd": cmd, **params}
+ 184        return self._request(
+ 185            "commit",
+ 186            method=method,
+ 187            params=params,
+ 188            remove_blank_text=remove_blank_text,
+ 189            verify=verify,
+ 190            timeout=timeout,
+ 191        )
+ 192
+ 193    # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/get-started-with-the-pan-os-xml-api/get-your-api-key
+ 194    def generate_apikey(self, username, password: str) -> str:
+ 195        """
+ 196        Generate a new API-Key for the user connected.
+ 197        """
+ 198        params = {"user": username, "password": password}
+ 199        return self._request(
+ 200            "keygen",
+ 201            method="POST",
+ 202            params=params,
+ 203        ).xpath(".//key/text()")[0]
+ 204
+ 205    # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/get-version-info-api
+ 206    def api_version(self):
+ 207        return el2dict(
+ 208            self._request(
+ 209                "version",
+ 210                method="POST",
+ 211            ).xpath(".//result")[0]
+ 212        )["result"]
+ 213
+ 214    def configuration(
+ 215        self,
+ 216        xpath,
+ 217        action="get",
+ 218        method="GET",
+ 219        params=None,
+ 220        remove_blank_text=True,
+ 221    ):
+ 222        return self._conf_request(
+ 223            xpath,
+ 224            action=action,
+ 225            method=method,
+ 226            params=params,
+ 227            remove_blank_text=remove_blank_text,
+ 228        )
+ 229
+ 230    def operation(
+ 231        self,
+ 232        cmd,
+ 233        method="POST",
+ 234        params=None,
+ 235        remove_blank_text=True,
+ 236    ):
+ 237        return self._op_request(
+ 238            cmd,
+ 239            method=method,
+ 240            params=params,
+ 241            remove_blank_text=remove_blank_text,
+ 242        )
+ 243
+ 244    def _check_is_panorama(self) -> bool:
+ 245        try:
+ 246            self.configuration("/config/panorama/vsys")
+ 247            return False
+ 248        except Exception:
+ 249            return True
+ 250
+ 251    @property
+ 252    def ispanorama(self):
+ 253        if self._ispanorama is None:
+ 254            self._ispanorama = self._check_is_panorama()
+ 255        return self._ispanorama
+ 256
+ 257    def get_tree(self, extended=False) -> Element:
+ 258        """
+ 259        Return the running configuration
+ 260        The differences with `running_config` are not known
+ 261        """
+ 262        tree = get_tree(
+ 263            self._host, self._api_key, verify=self._verify, logger=self.logger
+ 264        )
+ 265        if extended:
+ 266            self._extend_tree_information(tree)
+ 267        return tree
+ 268
+ 269    def _get_rule_use(self, device_group, position, rule_type, number: int = 200):
+ 270        results = []
+ 271        for i in range(100):
+ 272            cmd = _get_rule_use_cmd(
+ 273                device_group,
+ 274                position,
+ 275                rule_type,
+ 276                i * number,
+ 277                number,
+ 278            )
+ 279            res = self._op_request(cmd).xpath("result")[0]
+ 280            total_count = int(res.attrib["total-count"])
+ 281            results.extend(res.xpath("entry"))
+ 282            if len(results) >= total_count:
+ 283                break
+ 284        return results
+ 285
+ 286    def get_rule_use(self, tree=None, max_threads: Optional[int] = None):
+ 287        if tree is None:
+ 288            tree = self.get_tree()
+ 289        device_groups = tree.xpath("devices/*/device-group/*/@name")
+ 290        positions = ("pre", "post")
+ 291        # rule_types = tuple({x.tag for x in tree.xpath(
+ 292        # "devices/*/device-group/*"
+ 293        # "/*[self::post-rulebase or self::pre-rulebase]/*")})
+ 294        rule_types = ("security", "pbf", "nat", "application-override")
+ 295        args_list = list(product(device_groups, positions, rule_types))
+ 296
+ 297        def func(args):
+ 298            return self._get_rule_use(*args)
+ 299
+ 300        threads = len(args_list)
+ 301        threads = min(max_threads or threads, threads)
+ 302        with Pool(len(args_list)) as pool:
+ 303            data = pool.map(func, args_list)
+ 304        return [entry for entry_list in data for entry in entry_list]
+ 305
+ 306    def _get_rule_hit_count(self, device_group, rulebase, rule_type):
+ 307        cmd = (
+ 308            "<show><rule-hit-count><device-group>"
+ 309            f"<entry name='{device_group}'><{rulebase}><entry name='{rule_type}'>"
+ 310            f"<rules><all/></rules></entry></{rulebase}></entry>"
+ 311            "</device-group></rule-hit-count></show>"
+ 312        )
+ 313        res = self._op_request(cmd)
+ 314        entries = res.xpath(".//rules/entry") or []
+ 315        # return entries
+ 316        return [(device_group, rulebase, rule_type, e) for e in entries]
+ 317
+ 318    def get_rule_hit_count(self, tree=None, max_threads=None):
+ 319        if tree is None:
+ 320            tree = self.get_tree()
+ 321        device_groups = tree.xpath("devices/*/device-group/*/@name")
+ 322        rulebases = ("pre-rulebase", "post-rulebase")
+ 323        rule_types = ("security", "pbf", "nat", "application-override")
+ 324        args_list = list(product(device_groups, rulebases, rule_types))
+ 325
+ 326        def func(args):
+ 327            return self._get_rule_hit_count(*args)
+ 328
+ 329        threads = len(args_list)
+ 330        threads = min(max_threads or threads, threads)
+ 331        with Pool(len(args_list)) as pool:
+ 332            data = pool.map(func, args_list)
+ 333        return [entry for entry_list in data for entry in entry_list]
+ 334
+ 335    def _extend_tree_information(
+ 336        self,
+ 337        tree,
+ 338        extended=None,
+ 339        max_threads=None,
+ 340    ):
+ 341        """
+ 342        Incorporate usage statistics into the configuration.
+ 343        tree: the configuration as a XML object
+ 344        extended: rule-use data (if not provided, the function will retrieve them automatically)
+ 345        """
+ 346        if extended is None:
+ 347            extended = self.get_rule_use(tree, max_threads=max_threads)
+ 348        rules = tree.xpath(
+ 349            ".//device-group/entry/"
+ 350            "*[self::pre-rulebase or self::post-rulebase]/*/rules/entry[@uuid]",
+ 351        )
+ 352        ext_dict = {x.attrib.get("uuid"): x for x in extended}
+ 353        rules_dict = {x.attrib["uuid"]: x for x in rules}
+ 354        for ext, rule in map_dicts(ext_dict, rules_dict):
+ 355            extend_element(rule, ext)
+ 356            # NOTE: Do not use rule.extend(ext)
+ 357            # => This is causing duplicates entries
+ 358        return tree, extended
+ 359
+ 360    def get(self, xpath: str):
+ 361        """
+ 362        This will retrieve the xml definition based on the xpath
+ 363        The xpath doesn't need to be exact
+ 364        and can select multiple values at once.
+ 365        Still, it must at least speciy /config at is begining
+ 366        """
+ 367        return self._conf_request(xpath, action="show", method="GET")
+ 368
+ 369    def delete(self, xpath: str):
+ 370        """
+ 371        This will REMOVE the xml definition at the provided xpath.
+ 372        The xpath must be exact.
+ 373        """
+ 374        return self._conf_request(
+ 375            xpath,
+ 376            action="delete",
+ 377            method="DELETE",
+ 378        )
+ 379
+ 380    def create(self, xpath: str, xml_definition):
+ 381        """
+ 382        This will ADD the xml definition
+ 383        INSIDE the element at the provided xpath.
+ 384        The xpath must be exact.
+ 385        """
+ 386        # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration
+ 387        params = {"element": xml_definition}
+ 388        return self._conf_request(
+ 389            xpath,
+ 390            action="set",
+ 391            method="POST",
+ 392            params=params,
+ 393        )
+ 394
+ 395    def update(self, xpath: str, xml_definition):
+ 396        """
+ 397        This will REPLACE the xml definition
+ 398        INSTEAD of the element at the provided xpath
+ 399        The xpath must be exact.
+ 400        Nb: We can pull the whole config, update it locally,
+ 401        and push the final result
+ 402        """
+ 403        # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration
+ 404        params = {"element": xml_definition}
+ 405        return self._conf_request(
+ 406            xpath,
+ 407            action="edit",
+ 408            method="POST",
+ 409            params=params,
+ 410        )
+ 411
+ 412    def revert_changes(self, skip_validated: bool = False):
+ 413        """
+ 414        Revert all the changes made on Panorama.
+ 415        NOTE:
+ 416        - This only applies on non-commited changes.
+ 417        - This revert everything (not scoped by users)
+ 418
+ 419        skip_validated: Do not revert changes that were validated
+ 420        """
+ 421        skip = "<skip-validate>yes</skip-validate>" if skip_validated else ""
+ 422        cmd = f"<revert><config>{skip}</config></revert>"
+ 423        return self._op_request(cmd)
+ 424
+ 425    def validate_changes(self):
+ 426        """
+ 427        Validated all the changes currently made
+ 428        """
+ 429        cmd = "<validate><full></full></validate>"
+ 430        return self._op_request(cmd)
+ 431
+ 432    def _raw_get_push_scope(self, admin=None):
+ 433        """
+ 434        Gives detailed information about pending changes
+ 435        (e.g. xpath, owner, action, ...)
+ 436        """
+ 437        filter = f"<admin><member>{admin}</member></admin>" if admin else ""
+ 438        cmd = f"<show><config><push-scope>{filter}</push-scope></config></show>"
+ 439        return self._op_request(cmd)
+ 440
+ 441    def get_push_scope_devicegroups(self, admin=None):
+ 442        """
+ 443        Gives detailed information about pending changes
+ 444        (e.g. xpath, owner, action, ...)
+ 445        """
+ 446        scope = self._raw_get_push_scope(admin=admin)
+ 447        return list(set(scope.xpath(".//objects/entry[@loc-type='device-group']/@loc")))
+ 448
+ 449    def uncommited_changes(self):
+ 450        """
+ 451        Gives detailed information about pending changes
+ 452        (e.g. xpath, owner, action, ...)
+ 453        """
+ 454        cmd = "<show><config><list><changes></changes></list></config></show>"
+ 455        return self._op_request(cmd)
+ 456
+ 457    def uncommited_changes_summary(self, admin=None):
+ 458        """
+ 459        Only gives the concern device groups
+ 460        """
+ 461        admin = (
+ 462            f"<partial><admin><member>{admin}</member></admin></partial>"
+ 463            if admin
+ 464            else ""
+ 465        )
+ 466        cmd = f"<show><config><list><change-summary>{admin}</change-summary></list></config></show>"
+ 467        return self._op_request(cmd)
+ 468
+ 469    def pending_changes(self):
+ 470        """
+ 471        Result content is either 'yes' or 'no'
+ 472        """
+ 473        cmd = "<check><pending-changes></pending-changes></check>"
+ 474        return self._op_request(cmd)
+ 475
+ 476    def save_config(self, name):
+ 477        """
+ 478        Create a named snapshot of the current configuration
+ 479        """
+ 480        cmd = f"<save><config><to>{name}</to></config></save>"
+ 481        return "\n".join(self._op_request(cmd).xpath(".//result/text()"))
+ 482
+ 483    def save_device_state(self):
+ 484        """
+ 485        Create a snapshot of the current device state
+ 486        """
+ 487        cmd = "<save><device-state></device-state></save>"
+ 488        return "\n".join(self._op_request(cmd).xpath(".//result/text()"))
+ 489
+ 490    def get_named_configuration(self, name):
+ 491        """
+ 492        Get the configuration from a named snapshot as an XML object
+ 493        """
+ 494        cmd = f"<show><config><saved>{name}</saved></config></show>"
+ 495        return self._op_request(cmd, remove_blank_text=False).xpath("./result/config")[
+ 496            0
+ 497        ]
+ 498
+ 499    def candidate_config(self) -> Element:
+ 500        """
+ 501        Get the configuration to be commited as an XML object
+ 502        """
+ 503        cmd = "<show><config><candidate></candidate></config></show>"
+ 504        return self._op_request(cmd, remove_blank_text=False)
+ 505
+ 506    def running_config(self) -> Element:
+ 507        """
+ 508        Get the current running configuration as an XML object
+ 509        """
+ 510        cmd = "<show><config><running></running></config></show>"
+ 511        return self._op_request(cmd, remove_blank_text=False)
+ 512
+ 513    def _raw_get_jobs(self, job_ids: Union[None, str, List[str]] = None) -> Element:
+ 514        """
+ 515        Get information of job(s) as an XML object.
+ 516        Retrieve all jobs by default.
+ 517
+ 518        If job_id is provided, then only retrieve the job requested.
+ 519        """
+ 520        filter = "<all></all>"
+ 521        if job_ids:
+ 522            if isinstance(job_ids, str):
+ 523                job_ids = [job_ids]
+ 524            filter = "".join(f"<id>{j}</id>" for j in job_ids)
+ 525        cmd = f"<show><jobs>{filter}</jobs></show>"
+ 526        return self._op_request(cmd)
+ 527
+ 528    def get_jobs(self, job_ids: Union[None, str, List[str]] = None) -> List[types.Job]:
+ 529        """
+ 530        Get information of job(s)
+ 531        Retrieve all jobs by default.
+ 532
+ 533        If job_id is provided, then only retrieve the job requested.
+ 534        """
+ 535        job_xmls = self._raw_get_jobs(job_ids).xpath(".//job")
+ 536        transformed = (types.Job.from_xml(x) for x in job_xmls)
+ 537        return [j for j in transformed if j]
+ 538
+ 539    def get_job(self, job_id) -> types.Job:
+ 540        """
+ 541        Get information of job(s)
+ 542        Retrieve all jobs by default.
+ 543
+ 544        If job_id is provided, then only retrieve the job requested.
+ 545        """
+ 546        return self.get_jobs(job_id)[0]
+ 547
+ 548    def _raw_get_versions(self) -> Element:
+ 549        """
+ 550        Get the versions informations as a XML object.
+ 551        """
+ 552        cmd = "<request><system><software><check></check></software></system></request>"
+ 553        return self.operation(cmd)
+ 554
+ 555    def get_versions(self) -> List[types.SoftwareVersion]:
+ 556        """
+ 557        Get the versions informations
+ 558        """
+ 559        res = self._raw_get_versions()
+ 560        return [
+ 561            types.SoftwareVersion.from_xml(entry)
+ 562            for entry in res.xpath(".//sw-updates/versions/entry")
+ 563        ]
+ 564
+ 565    def wait_job_completion(self, job_id: str, waiter=None) -> types.Job:
+ 566        """
+ 567        Block until the job complete.
+ 568
+ 569        job_id: the job to wait upon
+ 570        waiter: a generator that yield when a new query must be done.
+ 571                see `wait` function (the default waiter) for an example
+ 572        """
+ 573        if not waiter:
+ 574            waiter = wait()
+ 575        for _ in waiter:
+ 576            job = self.get_job(job_id)
+ 577            if job.progress >= 100:
+ 578                return job
+ 579            self.logger.info(f"Job {job_id} progress: {job.progress}")
+ 580        raise Exception("Timeout while waiting for job completion")
+ 581
+ 582    def raw_get_pending_jobs(self):
+ 583        """
+ 584        Get all the jobs that are pending as a XML object
+ 585        """
+ 586        cmd = "<show><jobs><pending></pending></jobs></show>"
+ 587        return self._op_request(cmd)
+ 588
+ 589    def commit_changes(self, force: bool = False):
+ 590        """
+ 591        Commit all changes
+ 592        """
+ 593        cmd = "<commit>{}</commit>".format("<force></force>" if force else "")
+ 594        return self._commit_request(cmd)
+ 595
+ 596    def _lock_cmd(self, cmd, vsys, no_exception=False) -> bool:
+ 597        """
+ 598        Utility function for commands that tries to manipulate the lock
+ 599        on Panorama.
+ 600        """
+ 601        try:
+ 602            result = "".join(self._op_request(cmd, vsys=vsys).itertext())
+ 603            self.logger.debug(result)
+ 604        except Exception as e:
+ 605            if no_exception:
+ 606                self.logger.error(e)
+ 607                return False
+ 608            raise
+ 609        return True
+ 610
+ 611    # https://github.com/PaloAltoNetworks/pan-os-python/blob/a6b018e3864ff313fed36c3804394e2c92ca87b3/panos/base.py#L4459
+ 612    def add_config_lock(self, comment=None, vsys="shared", no_exception=False) -> bool:
+ 613        comment = f"<comment>{comment}</comment>" if comment else ""
+ 614        cmd = f"<request><config-lock><add>{comment}</add></config-lock></request>"
+ 615        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+ 616
+ 617    def remove_config_lock(self, vsys="shared", no_exception=False) -> bool:
+ 618        cmd = "<request><config-lock><remove></remove></config-lock></request>"
+ 619        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+ 620
+ 621    def add_commit_lock(self, comment=None, vsys="shared", no_exception=False) -> bool:
+ 622        comment = f"<comment>{comment}</comment>" if comment else ""
+ 623        cmd = f"<request><commit-lock><add>{comment}</add></commit-lock></request>"
+ 624        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+ 625
+ 626    def remove_commit_lock(self, vsys="shared", no_exception=False) -> bool:
+ 627        cmd = "<request><commit-lock><remove></remove></commit-lock></request>"
+ 628        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+ 629
+ 630    def set_ha_status(self, active: bool = True, target: Optional[str] = None):
+ 631        """
+ 632        Activate or Deactivate (suspend) the HA pair.
+ 633
+ 634        """
+ 635        status = "<functional></functional>" if active else "<suspend></suspend>"
+ 636        cmd = f"<request><high-availability><state>{status}</state></high-availability></request>"
+ 637        params = {"target": target} if target else None
+ 638        return self._op_request(cmd, params=params).xpath(".//result/text()")[0]
+ 639
+ 640    def set_ha_preemption(self, active=True, target=None):
+ 641        """
+ 642        NOT WORKING:
+ 643        There is currently no way to deactivate the preemption using the API.
+ 644        """
+ 645        raise Exception("set_ha_preemption not implementend")
+ 646
+ 647    def _raw_get_ha_info(self, state_only=False, target=None) -> Element:
+ 648        """
+ 649        Get the current state of a HA pair as a XML object.
+ 650        """
+ 651        filter = "<state></state>" if state_only else "<all></all>"
+ 652        cmd = f"<show><high-availability>{filter}</high-availability></show>"
+ 653        params = {"target": target} if target else None
+ 654        return self._op_request(cmd, params=params)
+ 655
+ 656    def get_ha_info(self, state_only=False, target=None) -> types.HAInfo:
+ 657        """
+ 658        Get the current state of a HA pair as a python object.
+ 659        """
+ 660        res = self._raw_get_ha_info(state_only=state_only, target=target)
+ 661        hainfo_xml = res.xpath(".//result")[0]
+ 662        # pprint(hainfo_xml)
+ 663        return types.HAInfo.from_xml(hainfo_xml)
+ 664
+ 665    def get_ha_pairs(
+ 666        self, connected=True
+ 667    ) -> Tuple[List[Tuple[types.Device, Optional[types.Device]]], List[types.Device]]:
+ 668        """
+ 669        Retrieve a tuple containing 2 values:
+ 670        1. The list of HA pairs and their members
+ 671        2. A list of devices that are not part of a HA pair
+ 672        """
+ 673        # Get all devices and index them using their serial number
+ 674        devices: List[types.Device] = self.get_devices(connected=connected)
+ 675        device_map = {d.serial: d for d in devices}
+ 676
+ 677        # Create the 2 lists by iterating over the devices
+ 678        done = set()
+ 679        ha_pairs = []
+ 680        without_ha = []
+ 681        for d in devices:
+ 682            # Do not manage twice the same device
+ 683            if d.serial in done:
+ 684                continue
+ 685            # The device does not have an HA peer
+ 686            if not d.ha_peer_serial:
+ 687                without_ha.append(d)
+ 688                done.add(d.serial)
+ 689                continue
+ 690            # Get the current device's HA peer
+ 691            # push them in the ha_pairs list
+ 692            # and mark both of them as done
+ 693            peer = device_map.get(d.ha_peer_serial)
+ 694            ha_pairs.append((d, peer))
+ 695            done.update((d.serial, d.ha_peer_serial))
+ 696        return ha_pairs, without_ha
+ 697
+ 698    def get_ha_pairs_map(self, connected=True):
+ 699        """
+ 700        Same as `get_ha_pairs`, but the ha_pairs are return as a map.
+ 701        This provides an easier and more readable lookup to find a pair:
+ 702
+ 703        mapping, _ = client.get_ha_pairs_map()
+ 704        serial = "12345"
+ 705        pair_of_serial = mapping[serial]
+ 706        """
+ 707        ha_pairs, without_ha = self.get_ha_pairs(connected=connected)
+ 708        map = {}
+ 709        for pair in ha_pairs:
+ 710            for device in pair:
+ 711                map[device.serial] = pair
+ 712        return map, without_ha
+ 713
+ 714    def get_panorama_status(self):
+ 715        """
+ 716        Get the current status of Panorama server.
+ 717        """
+ 718        cmd = "<show><panorama-status></panorama-status></show>"
+ 719        return self.operation(cmd).xpath(".//result")
+ 720
+ 721    def raw_get_local_panorama(self):
+ 722        return self.configuration(
+ 723            "/config/devices/entry/deviceconfig/system/panorama/local-panorama/panorama-server"
+ 724        )
+ 725
+ 726    def get_local_panorama_ip(self) -> Optional[str]:
+ 727        res = self.raw_get_local_panorama()
+ 728        return first(res.xpath("//panorama-server/text()"))
+ 729
+ 730    def _raw_get_devices(self, connected=False):
+ 731        """
+ 732        Return the list of device known from Panorama as a XML object.
+ 733        NOTE: This only works if the client is a Panorama server.
+ 734
+ 735        connected: only returns the devices that are connected
+ 736        """
+ 737        # This only works on Panorama, not the FW
+ 738        filter = "<connected></connected>" if connected else "<all></all>"
+ 739        cmd = f"<show><devices>{filter}</devices></show>"
+ 740        return self.operation(cmd)
+ 741
+ 742    def get_devices(self, connected=False) -> List[types.Device]:
+ 743        """
+ 744        Return the list of device known from Panorama as a python structure.
+ 745        NOTE: This only works if the client is a Panorama server.
+ 746
+ 747        connected: only returns the devices that are connected
+ 748        """
+ 749        res = self._raw_get_devices(connected=connected)
+ 750        entries = res.xpath(".//devices/entry")
+ 751        devices = (types.Device.from_xml(e) for e in entries)
+ 752        return [d for d in devices if d]
+ 753
+ 754    def _raw_get_dg_hierarchy(self):
+ 755        """
+ 756        Return the hierarchy of device groups as a XML object.
+ 757        """
+ 758        cmd = "<show><dg-hierarchy></dg-hierarchy></show>"
+ 759        return self.operation(cmd)
+ 760
+ 761    def get_plan_dg_hierarchy(self, recursive=False):
+ 762        """
+ 763        Return the hierarchy of device groups as a dict.
+ 764        The keys are the names of the device groups.
+ 765
+ 766        The values are the children device groups and depends on the recursive parameter.
+ 767        recursive: if False, the values are only the direct children of the device group.
+ 768            Otherwise, the values are all the descendant device groups.
+ 769        """
+ 770        devicegroups = {}  # name: children
+ 771        hierarchy = self._raw_get_dg_hierarchy().xpath(".//dg-hierarchy")[0]
+ 772        xpath = ".//dg" if recursive else "./dg"
+ 773        for dg in hierarchy.xpath(".//dg"):
+ 774            devicegroups[dg.attrib["name"]] = [
+ 775                x.attrib["name"] for x in dg.xpath(xpath)
+ 776            ]
+ 777        return devicegroups
+ 778
+ 779    def _raw_get_devicegroups(self):
+ 780        """
+ 781        Return the list of device groups as a XML object.
+ 782        """
+ 783        cmd = "<show><devicegroups></devicegroups></show>"
+ 784        return self.operation(cmd)
+ 785
+ 786    def get_devicegroups_name(
+ 787        self,
+ 788        parents=None,
+ 789        with_connected_devices=None,
+ 790    ):
+ 791        """
+ 792        This returns the names of the devicegroups:
+ 793        - parents: the returned list will only contain children of the provided parents (parents included)
+ 794        - with_devices: the returned list will only contain devicegroups that have direct devices under them
+ 795        """
+ 796        devicegroups = self._raw_get_devicegroups().xpath(".//devicegroups/entry")
+ 797        if with_connected_devices:
+ 798            names = [
+ 799                dg.attrib["name"]
+ 800                for dg in devicegroups
+ 801                if dg.xpath("./devices/entry/connected[text() = 'yes']")
+ 802            ]
+ 803        else:
+ 804            names = [dg.attrib["name"] for dg in devicegroups]
+ 805        if parents:
+ 806            hierarchy = self.get_plan_dg_hierarchy(recursive=True)
+ 807            tokeep = set(chain(*(hierarchy.get(p, []) for p in parents))) | set(parents)
+ 808            names = list(set(names) & tokeep)
+ 809        return names
+ 810
+ 811    def _raw_get_addresses(self):
+ 812        """
+ 813        Return the list of addresses known from Panorama as a XML object.
+ 814        NOTE: This only works if the client is a Firewall.
+ 815        """
+ 816        if self.ispanorama:
+ 817            return self.configuration(
+ 818                "/config/devices/entry/device-group/entry/address"
+ 819            )
+ 820        return self.configuration("/config/panorama/vsys//address")
+ 821
+ 822    def get_addresses(self) -> List[types.Address]:
+ 823        """
+ 824        Return the list of addresses known from Panorama as a python structure.
+ 825        NOTE: This only works if the client is a Firewall.
+ 826        """
+ 827        res = self._raw_get_addresses()
+ 828        addresses = res.xpath(".//address/entry")
+ 829        return [types.Address.from_xml(i) for i in addresses]
+ 830
+ 831    def _raw_get_routing_tables(self) -> Element:
+ 832        """
+ 833        Return the list of interfaces known from Panorama as a XML object.
+ 834        NOTE: This only works if the client is a Firewall.
+ 835        """
+ 836        return self.configuration(
+ 837            "/config/devices/entry/network/virtual-router/entry/routing-table"
+ 838        )
+ 839
+ 840    def get_routing_tables(self) -> List[types.RoutingTable]:
+ 841        """
+ 842        Return the list of interface known from Panorama as a python structure.
+ 843        NOTE: This only works if the client is a Firewall.
+ 844        """
+ 845        res = self._raw_get_routing_tables()
+ 846        routing_tables = res.xpath(".//routing-table")
+ 847        # print(len(routing_tables))
+ 848        # from pa_api.xmlapi.utils import pprint
+ 849        # for r in routing_tables:
+ 850        #     pprint(r)
+ 851        return [types.RoutingTable.from_xml(i) for i in routing_tables]
+ 852
+ 853    def _raw_get_interfaces(self) -> Element:
+ 854        """
+ 855        Return the list of interfaces known from Panorama as a XML object.
+ 856        NOTE: This only works if the client is a Firewall.
+ 857        """
+ 858        return self.configuration("/config/devices/entry/network/interface")
+ 859
+ 860    def get_interfaces(self) -> List[types.Interface]:
+ 861        """
+ 862        Return the list of interface known from Panorama as a python structure.
+ 863        NOTE: This only works if the client is a Firewall.
+ 864        """
+ 865        res = self._raw_get_interfaces()
+ 866        interfaces = res.xpath(".//interface")
+ 867        return [types.Interface.from_xml(i) for i in interfaces]
+ 868
+ 869    def _raw_get_zones(self) -> Element:
+ 870        """
+ 871        Return the list of zones known from Panorama as a XML object.
+ 872        NOTE: This only works if the client is a Firewall.
+ 873        """
+ 874        if self.ispanorama:
+ 875            return self.configuration(
+ 876                "/config/devices/entry/*/entry/config/devices/entry/vsys/entry/zone"
+ 877            )
+ 878        return self.configuration("/config/devices/entry/vsys/entry/zone")
+ 879
+ 880    def get_zones(self) -> Element:
+ 881        """
+ 882        Return the list of zones known from Panorama as a python structure.
+ 883        NOTE: This only works if the client is a Firewall.
+ 884        """
+ 885        res = self._raw_get_zones()
+ 886        zones = res.xpath(".//zone/entry")
+ 887        return [types.Zone.from_xml(i) for i in zones]
+ 888
+ 889    def _raw_get_templates(self, name=None) -> Element:
+ 890        """
+ 891        Return the synchronization status the templates per devices as a XML object.
+ 892        A device is in sync if it is up-to-date with the current version on Panorama.
+ 893        NOTE: This only works on Panorama.
+ 894        """
+ 895        # This only works on Panorama, not the FW
+ 896        filter = f"<name>{name}</name>" if name else ""
+ 897        cmd = f"<show><templates>{filter}</templates></show>"
+ 898        return self.operation(cmd)
+ 899
+ 900    def get_templates_sync_status(self):
+ 901        """
+ 902        Return the synchronization status the templates per devices
+ 903        A device is in sync if it is up-to-date with the current version on Panorama.
+ 904        NOTE: This only works on Panorama.
+ 905
+ 906        The result is a list of tuple of 3 values:
+ 907        1. the template's name
+ 908        2. the device's name
+ 909        3. the sync status
+ 910        """
+ 911        res = self._raw_get_templates()
+ 912        statuses = []
+ 913        for entry in res.xpath("./result/templates/entry"):
+ 914            template_name = entry.attrib["name"]
+ 915            for device in entry.xpath("./devices/entry"):
+ 916                device_name = device.attrib["name"]
+ 917                template_status = next(device.xpath("./template-status/text()"), None)
+ 918                status = (template_name, device_name, template_status)
+ 919                statuses.append(status)
+ 920        return statuses
+ 921
+ 922    def _raw_get_vpn_flows(self, name=None) -> List[Element]:
+ 923        """
+ 924        Returns the VPN flow information as a XML object.
+ 925        NOTE: This only works on Panorama server, not firewalls
+ 926        """
+ 927        # This only works on Panorama, not the FW"
+ 928        filter = f"<name>{name}</name>" if name else "<all></all>"
+ 929        cmd = f"<show><vpn><flow>{filter}</flow></vpn></show>"
+ 930        return self.operation(cmd)
+ 931
+ 932    def get_vpn_flows(self, name=None):
+ 933        """
+ 934        Returns the VPN flow information as a python structure.
+ 935        NOTE: This only works on Panorama server, not firewalls
+ 936        """
+ 937        entries = self._raw_get_vpn_flows(name=name).xpath(".//IPSec/entry")
+ 938        return [types.VPNFlow.from_xml(e) for e in entries]
+ 939
+ 940    def system_info(self):
+ 941        """
+ 942        Returns informations about the system as a XML object.
+ 943        """
+ 944        cmd = "<show><system><info></info></system></show>"
+ 945        return self.operation(cmd)
+ 946
+ 947    def _raw_system_resources(self):
+ 948        """
+ 949        Get the system resouces as a XML object.
+ 950        NOTE: The string is the raw output of a `ps` command.
+ 951        """
+ 952        cmd = "<show><system><resources></resources></system></show>"
+ 953        return self.operation(cmd)
+ 954
+ 955    def system_resources(self):
+ 956        """
+ 957        Get the system resouces as a string.
+ 958        The string is the raw output of a `ps` command.
+ 959        """
+ 960        res = self._raw_system_resources()
+ 961        text = res.xpath(".//result/text()")[0]
+ 962        return text.split("\n\n")[0]
+ 963
+ 964    def _raw_download_software(self, version):
+ 965        """
+ 966        Download the software version on the device.
+ 967        version: the software version to download
+ 968        """
+ 969        cmd = f"<request><system><software><download><version>{version}</version></download></software></system></request>"
+ 970        return self.operation(cmd)
+ 971
+ 972    def download_software(self, version) -> Optional[str]:
+ 973        """
+ 974        Download the software version on the device.
+ 975        version: the software version to download
+ 976
+ 977        Returns the download job's ID in case of successful launch,
+ 978        None is returned otherwise.
+ 979        """
+ 980        res = self._raw_download_software(version)
+ 981        try:
+ 982            return res.xpath(".//job/text()")[0]
+ 983        except Exception:
+ 984            self.logger.debug("Download has not started")
+ 985        return None
+ 986
+ 987    def _raw_install_software(self, version):
+ 988        """
+ 989        Install the software version on the device.
+ 990        version: the software version to install
+ 991        """
+ 992        cmd = f"<request><system><software><install><version>{version}</version></install></software></system></request>"
+ 993        return self.operation(cmd)
+ 994
+ 995    def install_software(
+ 996        self, version: Union[None, str, types.SoftwareVersion]
+ 997    ) -> Optional[str]:
+ 998        """
+ 999        Install the software version on the device.
+1000        version: the software version to install
+1001
+1002        Returns the download job's ID in case of successful launch,
+1003        None is returned otherwise.
+1004        """
+1005        if isinstance(version, types.SoftwareVersion):
+1006            version = version.version
+1007        res = self._raw_install_software(version)
+1008        try:
+1009            return res.xpath(".//job/text()")[0]
+1010        except Exception:
+1011            self.logger.debug("Download has not started")
+1012        return None
+1013
+1014    def _raw_restart(self):
+1015        """
+1016        Restart the device
+1017        """
+1018        cmd = "<request><restart><system></system></restart></request>"
+1019        return self.operation(cmd)
+1020
+1021    def restart(self):
+1022        """
+1023        Restart the device
+1024        """
+1025        return "".join(self._raw_restart().xpath(".//result/text()"))
+1026
+1027    def automatic_download_software(
+1028        self, version: Optional[str] = None
+1029    ) -> types.SoftwareVersion:
+1030        """
+1031        Automatically download the requested software version.
+1032        if the version is not provided, it defaults to the latest one.
+1033
+1034        NOTE: This does not do the installation.
+1035        This is usefull to download in anticipation of the upgrade.
+1036        For automatic install, see `automatic_software_upgrade`
+1037        """
+1038        version_str = version
+1039        versions = self.get_versions()
+1040        sw_version = None
+1041        if not version_str:
+1042            sw_version = next((v for v in versions if v.latest), None)
+1043        else:
+1044            sw_version = next((v for v in versions if v.version == version_str), None)
+1045        if not sw_version:
+1046            self.logger.error(f"Version {version_str} not found")
+1047            return exit(1)
+1048
+1049        # Already downloaded: Nothing to do
+1050        if sw_version.downloaded:
+1051            self.logger.info(f"Version {sw_version.version} already downloaded")
+1052            return sw_version
+1053
+1054        # Download minor version first (required)
+1055        base_version = next(
+1056            v for v in versions if v.version == sw_version.base_minor_version
+1057        )
+1058        if not base_version.downloaded:
+1059            self.logger.info(
+1060                f"Launching download of minor version {base_version.version}"
+1061            )
+1062            job_id = self.download_software(base_version.version)
+1063            if not job_id:
+1064                raise Exception("Download has not started")
+1065            job = self.wait_job_completion(job_id)
+1066            if job.result != "OK":
+1067                self.logger.debug(job)
+1068                raise Exception(job.details)
+1069            print(job.details)
+1070
+1071        # Actually download the wanted version
+1072        self.logger.info(f"Launching download of version {sw_version.version}")
+1073        job_id = self.download_software(sw_version.version)
+1074        if not job_id:
+1075            raise Exception("Download has not started")
+1076        job = self.wait_job_completion(job_id)
+1077        if job.result != "OK":
+1078            self.logger.debug(job)
+1079            raise Exception(job.details)
+1080        self.logger.info(job.details)
+1081        return sw_version
+1082
+1083    def automatic_software_upgrade(
+1084        self, version: Optional[str] = None, install: bool = True, restart: bool = True
+1085    ):
+1086        """
+1087        Automatically download and install the requested software version.
+1088        if the version is not provided, it defaults to the latest one.
+1089
+1090        NOTE: This does the software install and restart by default.
+1091        If you only want to download, prefer to use `automatic_download_software` method,
+1092        or set install=False. See the parameters for more information.
+1093
+1094        install: install the software after the download
+1095        restart: restart the device after the installation. This option is ignored if install=False
+1096
+1097        """
+1098        sw_version = self.automatic_download_software(version)
+1099        if sw_version.current:
+1100            self.logger.info(f"Version {sw_version.version} is already installed")
+1101            return sw_version
+1102        if not install:
+1103            return sw_version
+1104        # We may get the following error:
+1105        # "Error: Upgrading from 10.2.4-h10 to 11.1.2 requires a content version of 8761 or greater and found 8638-7689."
+1106        # This should never happen, we decided to report the error and handle this manually
+1107        self.logger.info(f"Launching install of version {sw_version.version}")
+1108
+1109        job_id = self.install_software(sw_version.version)
+1110        if not job_id:
+1111            self.logger.error("Install has not started")
+1112            raise Exception("Install has not started")
+1113        job = self.wait_job_completion(job_id)
+1114        self.logger.info(job.details)
+1115
+1116        # Do not restart if install failed
+1117        if job.result != "OK":
+1118            self.logger.error("Failed to install software version")
+1119            return sw_version
+1120
+1121        if restart:
+1122            self.logger.info("Restarting the device")
+1123            restart_response = self.restart()
+1124            self.logger.info(restart_response)
+1125        return sw_version
+
+ + + + +
+ +
+ + XMLApi( host=None, api_key=None, ispanorama=None, verify=False, timeout=None, logger=None) + + + +
+ + 
21    def __init__(
+22        self,
+23        host=None,
+24        api_key=None,
+25        ispanorama=None,
+26        verify=False,
+27        timeout=None,
+28        logger=None,
+29    ):
+30        env_host, env_apikey = get_credentials_from_env()
+31        host = host or env_host
+32        api_key = api_key or env_apikey
+33        if not host:
+34            raise Exception("Missing Host")
+35        if not api_key:
+36            raise Exception("Missing API Key")
+37        host, _, _ = clean_url_host(host)
+38
+39        self._host = host
+40        self._api_key = api_key
+41        self._url = f"{host}/api"
+42        self._verify = verify
+43        self._timeout = timeout
+44        self._ispanorama = ispanorama
+45        self.logger = logger or logging
+
+ + + + +
+
+
+ logger + + +
+ + + + +
+
+ +
+ + def + export_configuration( self, verify=None, timeout=None) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
103    def export_configuration(
+104        self,
+105        verify=None,
+106        timeout=None,
+107    ) -> Element:
+108        return self._export_request(
+109            category="configuration",
+110            verify=verify,
+111            timeout=timeout,
+112        )
+
+ + + + +
+
+ +
+ + def + export_device_state( self, verify=None, timeout=None) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
114    def export_device_state(
+115        self,
+116        verify=None,
+117        timeout=None,
+118    ) -> Element:
+119        return self._export_request(
+120            category="device-state",
+121            verify=verify,
+122            timeout=timeout,
+123        )
+
+ + + + +
+
+ +
+ + def + generate_apikey(self, username, password: str) -> str: + + + +
+ + 
194    def generate_apikey(self, username, password: str) -> str:
+195        """
+196        Generate a new API-Key for the user connected.
+197        """
+198        params = {"user": username, "password": password}
+199        return self._request(
+200            "keygen",
+201            method="POST",
+202            params=params,
+203        ).xpath(".//key/text()")[0]
+
+ + +

Generate a new API-Key for the user connected.

+
+ + +
+
+ +
+ + def + api_version(self): + + + +
+ + 
206    def api_version(self):
+207        return el2dict(
+208            self._request(
+209                "version",
+210                method="POST",
+211            ).xpath(".//result")[0]
+212        )["result"]
+
+ + + + +
+
+ +
+ + def + configuration( self, xpath, action='get', method='GET', params=None, remove_blank_text=True): + + + +
+ + 
214    def configuration(
+215        self,
+216        xpath,
+217        action="get",
+218        method="GET",
+219        params=None,
+220        remove_blank_text=True,
+221    ):
+222        return self._conf_request(
+223            xpath,
+224            action=action,
+225            method=method,
+226            params=params,
+227            remove_blank_text=remove_blank_text,
+228        )
+
+ + + + +
+
+ +
+ + def + operation(self, cmd, method='POST', params=None, remove_blank_text=True): + + + +
+ + 
230    def operation(
+231        self,
+232        cmd,
+233        method="POST",
+234        params=None,
+235        remove_blank_text=True,
+236    ):
+237        return self._op_request(
+238            cmd,
+239            method=method,
+240            params=params,
+241            remove_blank_text=remove_blank_text,
+242        )
+
+ + + + +
+
+ +
+ ispanorama + + + +
+ + 
251    @property
+252    def ispanorama(self):
+253        if self._ispanorama is None:
+254            self._ispanorama = self._check_is_panorama()
+255        return self._ispanorama
+
+ + + + +
+
+ +
+ + def + get_tree(self, extended=False) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
257    def get_tree(self, extended=False) -> Element:
+258        """
+259        Return the running configuration
+260        The differences with `running_config` are not known
+261        """
+262        tree = get_tree(
+263            self._host, self._api_key, verify=self._verify, logger=self.logger
+264        )
+265        if extended:
+266            self._extend_tree_information(tree)
+267        return tree
+
+ + +

Return the running configuration +The differences with running_config are not known

+
+ + +
+
+ +
+ + def + get_rule_use(self, tree=None, max_threads: Optional[int] = None): + + + +
+ + 
286    def get_rule_use(self, tree=None, max_threads: Optional[int] = None):
+287        if tree is None:
+288            tree = self.get_tree()
+289        device_groups = tree.xpath("devices/*/device-group/*/@name")
+290        positions = ("pre", "post")
+291        # rule_types = tuple({x.tag for x in tree.xpath(
+292        # "devices/*/device-group/*"
+293        # "/*[self::post-rulebase or self::pre-rulebase]/*")})
+294        rule_types = ("security", "pbf", "nat", "application-override")
+295        args_list = list(product(device_groups, positions, rule_types))
+296
+297        def func(args):
+298            return self._get_rule_use(*args)
+299
+300        threads = len(args_list)
+301        threads = min(max_threads or threads, threads)
+302        with Pool(len(args_list)) as pool:
+303            data = pool.map(func, args_list)
+304        return [entry for entry_list in data for entry in entry_list]
+
+ + + + +
+
+ +
+ + def + get_rule_hit_count(self, tree=None, max_threads=None): + + + +
+ + 
318    def get_rule_hit_count(self, tree=None, max_threads=None):
+319        if tree is None:
+320            tree = self.get_tree()
+321        device_groups = tree.xpath("devices/*/device-group/*/@name")
+322        rulebases = ("pre-rulebase", "post-rulebase")
+323        rule_types = ("security", "pbf", "nat", "application-override")
+324        args_list = list(product(device_groups, rulebases, rule_types))
+325
+326        def func(args):
+327            return self._get_rule_hit_count(*args)
+328
+329        threads = len(args_list)
+330        threads = min(max_threads or threads, threads)
+331        with Pool(len(args_list)) as pool:
+332            data = pool.map(func, args_list)
+333        return [entry for entry_list in data for entry in entry_list]
+
+ + + + +
+
+ +
+ + def + get(self, xpath: str): + + + +
+ + 
360    def get(self, xpath: str):
+361        """
+362        This will retrieve the xml definition based on the xpath
+363        The xpath doesn't need to be exact
+364        and can select multiple values at once.
+365        Still, it must at least speciy /config at is begining
+366        """
+367        return self._conf_request(xpath, action="show", method="GET")
+
+ + +

This will retrieve the xml definition based on the xpath +The xpath doesn't need to be exact +and can select multiple values at once. +Still, it must at least speciy /config at is begining

+
+ + +
+
+ +
+ + def + delete(self, xpath: str): + + + +
+ + 
369    def delete(self, xpath: str):
+370        """
+371        This will REMOVE the xml definition at the provided xpath.
+372        The xpath must be exact.
+373        """
+374        return self._conf_request(
+375            xpath,
+376            action="delete",
+377            method="DELETE",
+378        )
+
+ + +

This will REMOVE the xml definition at the provided xpath. +The xpath must be exact.

+
+ + +
+
+ +
+ + def + create(self, xpath: str, xml_definition): + + + +
+ + 
380    def create(self, xpath: str, xml_definition):
+381        """
+382        This will ADD the xml definition
+383        INSIDE the element at the provided xpath.
+384        The xpath must be exact.
+385        """
+386        # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration
+387        params = {"element": xml_definition}
+388        return self._conf_request(
+389            xpath,
+390            action="set",
+391            method="POST",
+392            params=params,
+393        )
+
+ + +

This will ADD the xml definition +INSIDE the element at the provided xpath. +The xpath must be exact.

+
+ + +
+
+ +
+ + def + update(self, xpath: str, xml_definition): + + + +
+ + 
395    def update(self, xpath: str, xml_definition):
+396        """
+397        This will REPLACE the xml definition
+398        INSTEAD of the element at the provided xpath
+399        The xpath must be exact.
+400        Nb: We can pull the whole config, update it locally,
+401        and push the final result
+402        """
+403        # https://docs.paloaltonetworks.com/pan-os/9-1/pan-os-panorama-api/pan-os-xml-api-request-types/configuration-api/set-configuration
+404        params = {"element": xml_definition}
+405        return self._conf_request(
+406            xpath,
+407            action="edit",
+408            method="POST",
+409            params=params,
+410        )
+
+ + +

This will REPLACE the xml definition +INSTEAD of the element at the provided xpath +The xpath must be exact. +Nb: We can pull the whole config, update it locally, +and push the final result

+
+ + +
+
+ +
+ + def + revert_changes(self, skip_validated: bool = False): + + + +
+ + 
412    def revert_changes(self, skip_validated: bool = False):
+413        """
+414        Revert all the changes made on Panorama.
+415        NOTE:
+416        - This only applies on non-commited changes.
+417        - This revert everything (not scoped by users)
+418
+419        skip_validated: Do not revert changes that were validated
+420        """
+421        skip = "<skip-validate>yes</skip-validate>" if skip_validated else ""
+422        cmd = f"<revert><config>{skip}</config></revert>"
+423        return self._op_request(cmd)
+
+ + +

Revert all the changes made on Panorama. +NOTE:

+ +
    +
  • This only applies on non-commited changes.
    • +
  • This revert everything (not scoped by users)
    • +
+ +

skip_validated: Do not revert changes that were validated

+
+ + +
+
+ +
+ + def + validate_changes(self): + + + +
+ + 
425    def validate_changes(self):
+426        """
+427        Validated all the changes currently made
+428        """
+429        cmd = "<validate><full></full></validate>"
+430        return self._op_request(cmd)
+
+ + +

Validated all the changes currently made

+
+ + +
+
+ +
+ + def + get_push_scope_devicegroups(self, admin=None): + + + +
+ + 
441    def get_push_scope_devicegroups(self, admin=None):
+442        """
+443        Gives detailed information about pending changes
+444        (e.g. xpath, owner, action, ...)
+445        """
+446        scope = self._raw_get_push_scope(admin=admin)
+447        return list(set(scope.xpath(".//objects/entry[@loc-type='device-group']/@loc")))
+
+ + +

Gives detailed information about pending changes +(e.g. xpath, owner, action, ...)

+
+ + +
+
+ +
+ + def + uncommited_changes(self): + + + +
+ + 
449    def uncommited_changes(self):
+450        """
+451        Gives detailed information about pending changes
+452        (e.g. xpath, owner, action, ...)
+453        """
+454        cmd = "<show><config><list><changes></changes></list></config></show>"
+455        return self._op_request(cmd)
+
+ + +

Gives detailed information about pending changes +(e.g. xpath, owner, action, ...)

+
+ + +
+
+ +
+ + def + uncommited_changes_summary(self, admin=None): + + + +
+ + 
457    def uncommited_changes_summary(self, admin=None):
+458        """
+459        Only gives the concern device groups
+460        """
+461        admin = (
+462            f"<partial><admin><member>{admin}</member></admin></partial>"
+463            if admin
+464            else ""
+465        )
+466        cmd = f"<show><config><list><change-summary>{admin}</change-summary></list></config></show>"
+467        return self._op_request(cmd)
+
+ + +

Only gives the concern device groups

+
+ + +
+
+ +
+ + def + pending_changes(self): + + + +
+ + 
469    def pending_changes(self):
+470        """
+471        Result content is either 'yes' or 'no'
+472        """
+473        cmd = "<check><pending-changes></pending-changes></check>"
+474        return self._op_request(cmd)
+
+ + +

Result content is either 'yes' or 'no'

+
+ + +
+
+ +
+ + def + save_config(self, name): + + + +
+ + 
476    def save_config(self, name):
+477        """
+478        Create a named snapshot of the current configuration
+479        """
+480        cmd = f"<save><config><to>{name}</to></config></save>"
+481        return "\n".join(self._op_request(cmd).xpath(".//result/text()"))
+
+ + +

Create a named snapshot of the current configuration

+
+ + +
+
+ +
+ + def + save_device_state(self): + + + +
+ + 
483    def save_device_state(self):
+484        """
+485        Create a snapshot of the current device state
+486        """
+487        cmd = "<save><device-state></device-state></save>"
+488        return "\n".join(self._op_request(cmd).xpath(".//result/text()"))
+
+ + +

Create a snapshot of the current device state

+
+ + +
+
+ +
+ + def + get_named_configuration(self, name): + + + +
+ + 
490    def get_named_configuration(self, name):
+491        """
+492        Get the configuration from a named snapshot as an XML object
+493        """
+494        cmd = f"<show><config><saved>{name}</saved></config></show>"
+495        return self._op_request(cmd, remove_blank_text=False).xpath("./result/config")[
+496            0
+497        ]
+
+ + +

Get the configuration from a named snapshot as an XML object

+
+ + +
+
+ +
+ + def + candidate_config(self) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
499    def candidate_config(self) -> Element:
+500        """
+501        Get the configuration to be commited as an XML object
+502        """
+503        cmd = "<show><config><candidate></candidate></config></show>"
+504        return self._op_request(cmd, remove_blank_text=False)
+
+ + +

Get the configuration to be commited as an XML object

+
+ + +
+
+ +
+ + def + running_config(self) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
506    def running_config(self) -> Element:
+507        """
+508        Get the current running configuration as an XML object
+509        """
+510        cmd = "<show><config><running></running></config></show>"
+511        return self._op_request(cmd, remove_blank_text=False)
+
+ + +

Get the current running configuration as an XML object

+
+ + +
+
+ +
+ + def + get_jobs( self, job_ids: Union[NoneType, str, List[str]] = None) -> List[pa_api.xmlapi.types.operations.job.Job]: + + + +
+ + 
528    def get_jobs(self, job_ids: Union[None, str, List[str]] = None) -> List[types.Job]:
+529        """
+530        Get information of job(s)
+531        Retrieve all jobs by default.
+532
+533        If job_id is provided, then only retrieve the job requested.
+534        """
+535        job_xmls = self._raw_get_jobs(job_ids).xpath(".//job")
+536        transformed = (types.Job.from_xml(x) for x in job_xmls)
+537        return [j for j in transformed if j]
+
+ + +

Get information of job(s) +Retrieve all jobs by default.

+ +

If job_id is provided, then only retrieve the job requested.

+
+ + +
+
+ +
+ + def + get_job(self, job_id) -> pa_api.xmlapi.types.operations.job.Job: + + + +
+ + 
539    def get_job(self, job_id) -> types.Job:
+540        """
+541        Get information of job(s)
+542        Retrieve all jobs by default.
+543
+544        If job_id is provided, then only retrieve the job requested.
+545        """
+546        return self.get_jobs(job_id)[0]
+
+ + +

Get information of job(s) +Retrieve all jobs by default.

+ +

If job_id is provided, then only retrieve the job requested.

+
+ + +
+
+ +
+ + def + get_versions(self) -> List[pa_api.xmlapi.types.operations.software.SoftwareVersion]: + + + +
+ + 
555    def get_versions(self) -> List[types.SoftwareVersion]:
+556        """
+557        Get the versions informations
+558        """
+559        res = self._raw_get_versions()
+560        return [
+561            types.SoftwareVersion.from_xml(entry)
+562            for entry in res.xpath(".//sw-updates/versions/entry")
+563        ]
+
+ + +

Get the versions informations

+
+ + +
+
+ +
+ + def + wait_job_completion(self, job_id: str, waiter=None) -> pa_api.xmlapi.types.operations.job.Job: + + + +
+ + 
565    def wait_job_completion(self, job_id: str, waiter=None) -> types.Job:
+566        """
+567        Block until the job complete.
+568
+569        job_id: the job to wait upon
+570        waiter: a generator that yield when a new query must be done.
+571                see `wait` function (the default waiter) for an example
+572        """
+573        if not waiter:
+574            waiter = wait()
+575        for _ in waiter:
+576            job = self.get_job(job_id)
+577            if job.progress >= 100:
+578                return job
+579            self.logger.info(f"Job {job_id} progress: {job.progress}")
+580        raise Exception("Timeout while waiting for job completion")
+
+ + +

Block until the job complete.

+ +

job_id: the job to wait upon +waiter: a generator that yield when a new query must be done. + see wait function (the default waiter) for an example

+
+ + +
+
+ +
+ + def + raw_get_pending_jobs(self): + + + +
+ + 
582    def raw_get_pending_jobs(self):
+583        """
+584        Get all the jobs that are pending as a XML object
+585        """
+586        cmd = "<show><jobs><pending></pending></jobs></show>"
+587        return self._op_request(cmd)
+
+ + +

Get all the jobs that are pending as a XML object

+
+ + +
+
+ +
+ + def + commit_changes(self, force: bool = False): + + + +
+ + 
589    def commit_changes(self, force: bool = False):
+590        """
+591        Commit all changes
+592        """
+593        cmd = "<commit>{}</commit>".format("<force></force>" if force else "")
+594        return self._commit_request(cmd)
+
+ + +

Commit all changes

+
+ + +
+
+ +
+ + def + add_config_lock(self, comment=None, vsys='shared', no_exception=False) -> bool: + + + +
+ + 
612    def add_config_lock(self, comment=None, vsys="shared", no_exception=False) -> bool:
+613        comment = f"<comment>{comment}</comment>" if comment else ""
+614        cmd = f"<request><config-lock><add>{comment}</add></config-lock></request>"
+615        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+
+ + + + +
+
+ +
+ + def + remove_config_lock(self, vsys='shared', no_exception=False) -> bool: + + + +
+ + 
617    def remove_config_lock(self, vsys="shared", no_exception=False) -> bool:
+618        cmd = "<request><config-lock><remove></remove></config-lock></request>"
+619        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+
+ + + + +
+
+ +
+ + def + add_commit_lock(self, comment=None, vsys='shared', no_exception=False) -> bool: + + + +
+ + 
621    def add_commit_lock(self, comment=None, vsys="shared", no_exception=False) -> bool:
+622        comment = f"<comment>{comment}</comment>" if comment else ""
+623        cmd = f"<request><commit-lock><add>{comment}</add></commit-lock></request>"
+624        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+
+ + + + +
+
+ +
+ + def + remove_commit_lock(self, vsys='shared', no_exception=False) -> bool: + + + +
+ + 
626    def remove_commit_lock(self, vsys="shared", no_exception=False) -> bool:
+627        cmd = "<request><commit-lock><remove></remove></commit-lock></request>"
+628        return self._lock_cmd(cmd, vsys=vsys, no_exception=no_exception)
+
+ + + + +
+
+ +
+ + def + set_ha_status(self, active: bool = True, target: Optional[str] = None): + + + +
+ + 
630    def set_ha_status(self, active: bool = True, target: Optional[str] = None):
+631        """
+632        Activate or Deactivate (suspend) the HA pair.
+633
+634        """
+635        status = "<functional></functional>" if active else "<suspend></suspend>"
+636        cmd = f"<request><high-availability><state>{status}</state></high-availability></request>"
+637        params = {"target": target} if target else None
+638        return self._op_request(cmd, params=params).xpath(".//result/text()")[0]
+
+ + +

Activate or Deactivate (suspend) the HA pair.

+
+ + +
+
+ +
+ + def + set_ha_preemption(self, active=True, target=None): + + + +
+ + 
640    def set_ha_preemption(self, active=True, target=None):
+641        """
+642        NOT WORKING:
+643        There is currently no way to deactivate the preemption using the API.
+644        """
+645        raise Exception("set_ha_preemption not implementend")
+
+ + +

NOT WORKING: +There is currently no way to deactivate the preemption using the API.

+
+ + +
+
+ +
+ + def + get_ha_info( self, state_only=False, target=None) -> pa_api.xmlapi.types.operations.device.HAInfo: + + + +
+ + 
656    def get_ha_info(self, state_only=False, target=None) -> types.HAInfo:
+657        """
+658        Get the current state of a HA pair as a python object.
+659        """
+660        res = self._raw_get_ha_info(state_only=state_only, target=target)
+661        hainfo_xml = res.xpath(".//result")[0]
+662        # pprint(hainfo_xml)
+663        return types.HAInfo.from_xml(hainfo_xml)
+
+ + +

Get the current state of a HA pair as a python object.

+
+ + +
+
+ +
+ + def + get_ha_pairs( self, connected=True) -> Tuple[List[Tuple[pa_api.xmlapi.types.operations.device.Device, Optional[pa_api.xmlapi.types.operations.device.Device]]], List[pa_api.xmlapi.types.operations.device.Device]]: + + + +
+ + 
665    def get_ha_pairs(
+666        self, connected=True
+667    ) -> Tuple[List[Tuple[types.Device, Optional[types.Device]]], List[types.Device]]:
+668        """
+669        Retrieve a tuple containing 2 values:
+670        1. The list of HA pairs and their members
+671        2. A list of devices that are not part of a HA pair
+672        """
+673        # Get all devices and index them using their serial number
+674        devices: List[types.Device] = self.get_devices(connected=connected)
+675        device_map = {d.serial: d for d in devices}
+676
+677        # Create the 2 lists by iterating over the devices
+678        done = set()
+679        ha_pairs = []
+680        without_ha = []
+681        for d in devices:
+682            # Do not manage twice the same device
+683            if d.serial in done:
+684                continue
+685            # The device does not have an HA peer
+686            if not d.ha_peer_serial:
+687                without_ha.append(d)
+688                done.add(d.serial)
+689                continue
+690            # Get the current device's HA peer
+691            # push them in the ha_pairs list
+692            # and mark both of them as done
+693            peer = device_map.get(d.ha_peer_serial)
+694            ha_pairs.append((d, peer))
+695            done.update((d.serial, d.ha_peer_serial))
+696        return ha_pairs, without_ha
+
+ + +

Retrieve a tuple containing 2 values:

+ +
    +
  1. The list of HA pairs and their members
    2. +
  2. A list of devices that are not part of a HA pair
    3. +
+
+ + +
+
+ +
+ + def + get_ha_pairs_map(self, connected=True): + + + +
+ + 
698    def get_ha_pairs_map(self, connected=True):
+699        """
+700        Same as `get_ha_pairs`, but the ha_pairs are return as a map.
+701        This provides an easier and more readable lookup to find a pair:
+702
+703        mapping, _ = client.get_ha_pairs_map()
+704        serial = "12345"
+705        pair_of_serial = mapping[serial]
+706        """
+707        ha_pairs, without_ha = self.get_ha_pairs(connected=connected)
+708        map = {}
+709        for pair in ha_pairs:
+710            for device in pair:
+711                map[device.serial] = pair
+712        return map, without_ha
+
+ + +

Same as get_ha_pairs, but the ha_pairs are return as a map. +This provides an easier and more readable lookup to find a pair:

+ +

mapping, _ = client.get_ha_pairs_map() +serial = "12345" +pair_of_serial = mapping[serial]

+
+ + +
+
+ +
+ + def + get_panorama_status(self): + + + +
+ + 
714    def get_panorama_status(self):
+715        """
+716        Get the current status of Panorama server.
+717        """
+718        cmd = "<show><panorama-status></panorama-status></show>"
+719        return self.operation(cmd).xpath(".//result")
+
+ + +

Get the current status of Panorama server.

+
+ + +
+
+ +
+ + def + raw_get_local_panorama(self): + + + +
+ + 
721    def raw_get_local_panorama(self):
+722        return self.configuration(
+723            "/config/devices/entry/deviceconfig/system/panorama/local-panorama/panorama-server"
+724        )
+
+ + + + +
+
+ +
+ + def + get_local_panorama_ip(self) -> Optional[str]: + + + +
+ + 
726    def get_local_panorama_ip(self) -> Optional[str]:
+727        res = self.raw_get_local_panorama()
+728        return first(res.xpath("//panorama-server/text()"))
+
+ + + + +
+
+ +
+ + def + get_devices( self, connected=False) -> List[pa_api.xmlapi.types.operations.device.Device]: + + + +
+ + 
742    def get_devices(self, connected=False) -> List[types.Device]:
+743        """
+744        Return the list of device known from Panorama as a python structure.
+745        NOTE: This only works if the client is a Panorama server.
+746
+747        connected: only returns the devices that are connected
+748        """
+749        res = self._raw_get_devices(connected=connected)
+750        entries = res.xpath(".//devices/entry")
+751        devices = (types.Device.from_xml(e) for e in entries)
+752        return [d for d in devices if d]
+
+ + +

Return the list of device known from Panorama as a python structure. +NOTE: This only works if the client is a Panorama server.

+ +

connected: only returns the devices that are connected

+
+ + +
+
+ +
+ + def + get_plan_dg_hierarchy(self, recursive=False): + + + +
+ + 
761    def get_plan_dg_hierarchy(self, recursive=False):
+762        """
+763        Return the hierarchy of device groups as a dict.
+764        The keys are the names of the device groups.
+765
+766        The values are the children device groups and depends on the recursive parameter.
+767        recursive: if False, the values are only the direct children of the device group.
+768            Otherwise, the values are all the descendant device groups.
+769        """
+770        devicegroups = {}  # name: children
+771        hierarchy = self._raw_get_dg_hierarchy().xpath(".//dg-hierarchy")[0]
+772        xpath = ".//dg" if recursive else "./dg"
+773        for dg in hierarchy.xpath(".//dg"):
+774            devicegroups[dg.attrib["name"]] = [
+775                x.attrib["name"] for x in dg.xpath(xpath)
+776            ]
+777        return devicegroups
+
+ + +

Return the hierarchy of device groups as a dict. +The keys are the names of the device groups.

+ +

The values are the children device groups and depends on the recursive parameter. +recursive: if False, the values are only the direct children of the device group. + Otherwise, the values are all the descendant device groups.

+
+ + +
+
+ +
+ + def + get_devicegroups_name(self, parents=None, with_connected_devices=None): + + + +
+ + 
786    def get_devicegroups_name(
+787        self,
+788        parents=None,
+789        with_connected_devices=None,
+790    ):
+791        """
+792        This returns the names of the devicegroups:
+793        - parents: the returned list will only contain children of the provided parents (parents included)
+794        - with_devices: the returned list will only contain devicegroups that have direct devices under them
+795        """
+796        devicegroups = self._raw_get_devicegroups().xpath(".//devicegroups/entry")
+797        if with_connected_devices:
+798            names = [
+799                dg.attrib["name"]
+800                for dg in devicegroups
+801                if dg.xpath("./devices/entry/connected[text() = 'yes']")
+802            ]
+803        else:
+804            names = [dg.attrib["name"] for dg in devicegroups]
+805        if parents:
+806            hierarchy = self.get_plan_dg_hierarchy(recursive=True)
+807            tokeep = set(chain(*(hierarchy.get(p, []) for p in parents))) | set(parents)
+808            names = list(set(names) & tokeep)
+809        return names
+
+ + +

This returns the names of the devicegroups:

+ +
    +
  • parents: the returned list will only contain children of the provided parents (parents included)
    • +
  • with_devices: the returned list will only contain devicegroups that have direct devices under them
    • +
+
+ + +
+
+ +
+ + def + get_addresses(self) -> List[pa_api.xmlapi.types.config.address.Address]: + + + +
+ + 
822    def get_addresses(self) -> List[types.Address]:
+823        """
+824        Return the list of addresses known from Panorama as a python structure.
+825        NOTE: This only works if the client is a Firewall.
+826        """
+827        res = self._raw_get_addresses()
+828        addresses = res.xpath(".//address/entry")
+829        return [types.Address.from_xml(i) for i in addresses]
+
+ + +

Return the list of addresses known from Panorama as a python structure. +NOTE: This only works if the client is a Firewall.

+
+ + +
+
+ +
+ + def + get_routing_tables( self) -> List[pa_api.xmlapi.types.config.routing.routing_table.RoutingTable]: + + + +
+ + 
840    def get_routing_tables(self) -> List[types.RoutingTable]:
+841        """
+842        Return the list of interface known from Panorama as a python structure.
+843        NOTE: This only works if the client is a Firewall.
+844        """
+845        res = self._raw_get_routing_tables()
+846        routing_tables = res.xpath(".//routing-table")
+847        # print(len(routing_tables))
+848        # from pa_api.xmlapi.utils import pprint
+849        # for r in routing_tables:
+850        #     pprint(r)
+851        return [types.RoutingTable.from_xml(i) for i in routing_tables]
+
+ + +

Return the list of interface known from Panorama as a python structure. +NOTE: This only works if the client is a Firewall.

+
+ + +
+
+ +
+ + def + get_interfaces(self) -> List[pa_api.xmlapi.types.config.interface.Interface]: + + + +
+ + 
860    def get_interfaces(self) -> List[types.Interface]:
+861        """
+862        Return the list of interface known from Panorama as a python structure.
+863        NOTE: This only works if the client is a Firewall.
+864        """
+865        res = self._raw_get_interfaces()
+866        interfaces = res.xpath(".//interface")
+867        return [types.Interface.from_xml(i) for i in interfaces]
+
+ + +

Return the list of interface known from Panorama as a python structure. +NOTE: This only works if the client is a Firewall.

+
+ + +
+
+ +
+ + def + get_zones(self) -> <cyfunction Element at 0x7ef48ad6e670>: + + + +
+ + 
880    def get_zones(self) -> Element:
+881        """
+882        Return the list of zones known from Panorama as a python structure.
+883        NOTE: This only works if the client is a Firewall.
+884        """
+885        res = self._raw_get_zones()
+886        zones = res.xpath(".//zone/entry")
+887        return [types.Zone.from_xml(i) for i in zones]
+
+ + +

Return the list of zones known from Panorama as a python structure. +NOTE: This only works if the client is a Firewall.

+
+ + +
+
+ +
+ + def + get_templates_sync_status(self): + + + +
+ + 
900    def get_templates_sync_status(self):
+901        """
+902        Return the synchronization status the templates per devices
+903        A device is in sync if it is up-to-date with the current version on Panorama.
+904        NOTE: This only works on Panorama.
+905
+906        The result is a list of tuple of 3 values:
+907        1. the template's name
+908        2. the device's name
+909        3. the sync status
+910        """
+911        res = self._raw_get_templates()
+912        statuses = []
+913        for entry in res.xpath("./result/templates/entry"):
+914            template_name = entry.attrib["name"]
+915            for device in entry.xpath("./devices/entry"):
+916                device_name = device.attrib["name"]
+917                template_status = next(device.xpath("./template-status/text()"), None)
+918                status = (template_name, device_name, template_status)
+919                statuses.append(status)
+920        return statuses
+
+ + +

Return the synchronization status the templates per devices +A device is in sync if it is up-to-date with the current version on Panorama. +NOTE: This only works on Panorama.

+ +

The result is a list of tuple of 3 values:

+ +
    +
  1. the template's name
    2. +
  2. the device's name
    3. +
  3. the sync status
    4. +
+
+ + +
+
+ +
+ + def + get_vpn_flows(self, name=None): + + + +
+ + 
932    def get_vpn_flows(self, name=None):
+933        """
+934        Returns the VPN flow information as a python structure.
+935        NOTE: This only works on Panorama server, not firewalls
+936        """
+937        entries = self._raw_get_vpn_flows(name=name).xpath(".//IPSec/entry")
+938        return [types.VPNFlow.from_xml(e) for e in entries]
+
+ + +

Returns the VPN flow information as a python structure. +NOTE: This only works on Panorama server, not firewalls

+
+ + +
+
+ +
+ + def + system_info(self): + + + +
+ + 
940    def system_info(self):
+941        """
+942        Returns informations about the system as a XML object.
+943        """
+944        cmd = "<show><system><info></info></system></show>"
+945        return self.operation(cmd)
+
+ + +

Returns informations about the system as a XML object.

+
+ + +
+
+ +
+ + def + system_resources(self): + + + +
+ + 
955    def system_resources(self):
+956        """
+957        Get the system resouces as a string.
+958        The string is the raw output of a `ps` command.
+959        """
+960        res = self._raw_system_resources()
+961        text = res.xpath(".//result/text()")[0]
+962        return text.split("\n\n")[0]
+
+ + +

Get the system resouces as a string. +The string is the raw output of a ps command.

+
+ + +
+
+ +
+ + def + download_software(self, version) -> Optional[str]: + + + +
+ + 
972    def download_software(self, version) -> Optional[str]:
+973        """
+974        Download the software version on the device.
+975        version: the software version to download
+976
+977        Returns the download job's ID in case of successful launch,
+978        None is returned otherwise.
+979        """
+980        res = self._raw_download_software(version)
+981        try:
+982            return res.xpath(".//job/text()")[0]
+983        except Exception:
+984            self.logger.debug("Download has not started")
+985        return None
+
+ + +

Download the software version on the device. +version: the software version to download

+ +

Returns the download job's ID in case of successful launch, +None is returned otherwise.

+
+ + +
+
+ +
+ + def + install_software( self, version: Union[NoneType, str, pa_api.xmlapi.types.operations.software.SoftwareVersion]) -> Optional[str]: + + + +
+ + 
 995    def install_software(
+ 996        self, version: Union[None, str, types.SoftwareVersion]
+ 997    ) -> Optional[str]:
+ 998        """
+ 999        Install the software version on the device.
+1000        version: the software version to install
+1001
+1002        Returns the download job's ID in case of successful launch,
+1003        None is returned otherwise.
+1004        """
+1005        if isinstance(version, types.SoftwareVersion):
+1006            version = version.version
+1007        res = self._raw_install_software(version)
+1008        try:
+1009            return res.xpath(".//job/text()")[0]
+1010        except Exception:
+1011            self.logger.debug("Download has not started")
+1012        return None
+
+ + +

Install the software version on the device. +version: the software version to install

+ +

Returns the download job's ID in case of successful launch, +None is returned otherwise.

+
+ + +
+
+ +
+ + def + restart(self): + + + +
+ + 
1021    def restart(self):
+1022        """
+1023        Restart the device
+1024        """
+1025        return "".join(self._raw_restart().xpath(".//result/text()"))
+
+ + +

Restart the device

+
+ + +
+
+ +
+ + def + automatic_download_software( self, version: Optional[str] = None) -> pa_api.xmlapi.types.operations.software.SoftwareVersion: + + + +
+ + 
1027    def automatic_download_software(
+1028        self, version: Optional[str] = None
+1029    ) -> types.SoftwareVersion:
+1030        """
+1031        Automatically download the requested software version.
+1032        if the version is not provided, it defaults to the latest one.
+1033
+1034        NOTE: This does not do the installation.
+1035        This is usefull to download in anticipation of the upgrade.
+1036        For automatic install, see `automatic_software_upgrade`
+1037        """
+1038        version_str = version
+1039        versions = self.get_versions()
+1040        sw_version = None
+1041        if not version_str:
+1042            sw_version = next((v for v in versions if v.latest), None)
+1043        else:
+1044            sw_version = next((v for v in versions if v.version == version_str), None)
+1045        if not sw_version:
+1046            self.logger.error(f"Version {version_str} not found")
+1047            return exit(1)
+1048
+1049        # Already downloaded: Nothing to do
+1050        if sw_version.downloaded:
+1051            self.logger.info(f"Version {sw_version.version} already downloaded")
+1052            return sw_version
+1053
+1054        # Download minor version first (required)
+1055        base_version = next(
+1056            v for v in versions if v.version == sw_version.base_minor_version
+1057        )
+1058        if not base_version.downloaded:
+1059            self.logger.info(
+1060                f"Launching download of minor version {base_version.version}"
+1061            )
+1062            job_id = self.download_software(base_version.version)
+1063            if not job_id:
+1064                raise Exception("Download has not started")
+1065            job = self.wait_job_completion(job_id)
+1066            if job.result != "OK":
+1067                self.logger.debug(job)
+1068                raise Exception(job.details)
+1069            print(job.details)
+1070
+1071        # Actually download the wanted version
+1072        self.logger.info(f"Launching download of version {sw_version.version}")
+1073        job_id = self.download_software(sw_version.version)
+1074        if not job_id:
+1075            raise Exception("Download has not started")
+1076        job = self.wait_job_completion(job_id)
+1077        if job.result != "OK":
+1078            self.logger.debug(job)
+1079            raise Exception(job.details)
+1080        self.logger.info(job.details)
+1081        return sw_version
+
+ + +

Automatically download the requested software version. +if the version is not provided, it defaults to the latest one.

+ +

NOTE: This does not do the installation. +This is usefull to download in anticipation of the upgrade. +For automatic install, see automatic_software_upgrade

+
+ + +
+
+ +
+ + def + automatic_software_upgrade( self, version: Optional[str] = None, install: bool = True, restart: bool = True): + + + +
+ + 
1083    def automatic_software_upgrade(
+1084        self, version: Optional[str] = None, install: bool = True, restart: bool = True
+1085    ):
+1086        """
+1087        Automatically download and install the requested software version.
+1088        if the version is not provided, it defaults to the latest one.
+1089
+1090        NOTE: This does the software install and restart by default.
+1091        If you only want to download, prefer to use `automatic_download_software` method,
+1092        or set install=False. See the parameters for more information.
+1093
+1094        install: install the software after the download
+1095        restart: restart the device after the installation. This option is ignored if install=False
+1096
+1097        """
+1098        sw_version = self.automatic_download_software(version)
+1099        if sw_version.current:
+1100            self.logger.info(f"Version {sw_version.version} is already installed")
+1101            return sw_version
+1102        if not install:
+1103            return sw_version
+1104        # We may get the following error:
+1105        # "Error: Upgrading from 10.2.4-h10 to 11.1.2 requires a content version of 8761 or greater and found 8638-7689."
+1106        # This should never happen, we decided to report the error and handle this manually
+1107        self.logger.info(f"Launching install of version {sw_version.version}")
+1108
+1109        job_id = self.install_software(sw_version.version)
+1110        if not job_id:
+1111            self.logger.error("Install has not started")
+1112            raise Exception("Install has not started")
+1113        job = self.wait_job_completion(job_id)
+1114        self.logger.info(job.details)
+1115
+1116        # Do not restart if install failed
+1117        if job.result != "OK":
+1118            self.logger.error("Failed to install software version")
+1119            return sw_version
+1120
+1121        if restart:
+1122            self.logger.info("Restarting the device")
+1123            restart_response = self.restart()
+1124            self.logger.info(restart_response)
+1125        return sw_version
+
+ + +

Automatically download and install the requested software version. +if the version is not provided, it defaults to the latest one.

+ +

NOTE: This does the software install and restart by default. +If you only want to download, prefer to use automatic_download_software method, +or set install=False. See the parameters for more information.

+ +

install: install the software after the download +restart: restart the device after the installation. This option is ignored if install=False

+
+ + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types.html b/public/pa_api/xmlapi/types.html new file mode 100644 index 0000000..c03c72d --- /dev/null +++ b/public/pa_api/xmlapi/types.html @@ -0,0 +1,272 @@ + + + + + + + pa_api.xmlapi.types API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types

+ + + + + + + 
 1from pa_api.utils import (
+ 2    first,
+ 3)
+ 4
+ 5from .config import (
+ 6    Address,
+ 7    AggregateEthernet,
+ 8    DeviceGroup,
+ 9    Ethernet,
+10    GenericInterface,
+11    Interface,
+12    Layer2,
+13    Layer3,
+14    Loopback,
+15    RoutingTable,
+16    RuleBase,
+17    Security,
+18    Vlan,
+19    Zone,
+20)
+21from .operations import (
+22    Device,
+23    HAInfo,
+24    Job,
+25    JobResult,
+26    SoftwareVersion,
+27    VPNFlow,
+28)
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config.html b/public/pa_api/xmlapi/types/config.html new file mode 100644 index 0000000..9a57a4f --- /dev/null +++ b/public/pa_api/xmlapi/types/config.html @@ -0,0 +1,261 @@ + + + + + + + pa_api.xmlapi.types.config API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config

+ + + + + + + 
 1from .address import Address
+ 2from .devicegroup import DeviceGroup
+ 3from .interface import (
+ 4    AggregateEthernet,
+ 5    Ethernet,
+ 6    GenericInterface,
+ 7    Interface,
+ 8    Layer2,
+ 9    Layer3,
+10    Loopback,
+11    Vlan,
+12)
+13from .routing import RoutingTable
+14from .rules import NAT, RuleBase, Security
+15from .zone import Zone
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/address.html b/public/pa_api/xmlapi/types/config/address.html new file mode 100644 index 0000000..b1519d7 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/address.html @@ -0,0 +1,799 @@ + + + + + + + pa_api.xmlapi.types.config.address API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.address

+ + + + + + + 
 1# Given a list of subnets,
+ 2# Find all NAT rules related to an address in the subnet
+ 3
+ 4from ipaddress import IPv4Network, IPv6Network, ip_network
+ 5from typing import Optional, Union
+ 6
+ 7from pydantic import AliasChoices, AliasPath, Field
+ 8from pydantic.functional_validators import field_validator, model_validator
+ 9from typing_extensions import Self
+10
+11from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+12
+13IPNetwork = Union[IPv4Network, IPv6Network]
+14
+15
+16def get_ip_network(ip_netmask):
+17    try:
+18        if ip_netmask:
+19            return ip_network(ip_netmask, strict=False)
+20    except Exception:
+21        return None
+22
+23
+24# https://docs.pydantic.dev/latest/concepts/alias/#aliaspath-and-aliaschoices
+25class Address(XMLBaseModel):
+26    name: str = Field(validation_alias="@name")
+27    type: Optional[str] = None
+28    prefix: Optional[str] = None
+29    ip_netmask: Optional[str] = Field(
+30        alias="ip-netmask",
+31        validation_alias=AliasChoices(
+32            AliasPath("ip-netmask", "#text"),
+33            "ip-netmask",
+34        ),
+35        default=None,
+36    )
+37    ip_network: Optional[IPNetwork] = None
+38    ip_range: Optional[str] = Field(alias="ip-range", default=None)
+39    fqdn: Optional[String] = None
+40    tags: List[String] = Field(
+41        validation_alias=AliasPath("tag", "member"), default=None
+42    )
+43
+44    @field_validator("tags", mode="before")
+45    @classmethod
+46    def validate_tags(cls, v) -> List[str]:
+47        if not v:
+48            return []
+49        if not isinstance(v, list):
+50            return [v]
+51        return v
+52
+53    @model_validator(mode="after")
+54    def validate_ip_network(self) -> Self:
+55        if self.ip_network is None:
+56            self.ip_network = get_ip_network(self.ip_netmask)
+57        if not isinstance(self.ip_network, (IPv4Network, IPv6Network)):
+58            self.ip_network = None
+59        return self
+60
+61    @model_validator(mode="after")
+62    def validate_type(self) -> Self:
+63        address_type = None
+64        if self.prefix:
+65            address_type = "prefix"
+66        elif self.ip_netmask:
+67            address_type = "ip-netmask"
+68        elif self.ip_range:
+69            address_type = "ip-range"
+70        elif self.fqdn:
+71            address_type = "fqdn"
+72        self.type = address_type
+73        return self
+74
+75
+76def find_addresses(tree):
+77    # addresses_xml = tree.xpath(".//address/entry")
+78    addresses_xml = tree.xpath("./devices/entry/device-group//address/entry")
+79    address_objects = [Address.from_xml(n) for n in addresses_xml]
+80
+81    addresses = []
+82    subnets = []
+83    for a in address_objects:
+84        network = a.ip_network
+85        # We do not consider ip ranges for now
+86        if not network:
+87            continue
+88        if network.prefixlen == network.max_prefixlen:
+89            addresses.append(a)
+90        else:
+91            subnets.append(a)
+92    return addresses, subnets
+
+ + +
+
+
+ IPNetwork = +typing.Union[ipaddress.IPv4Network, ipaddress.IPv6Network] + + +
+ + + + +
+
+ +
+ + def + get_ip_network(ip_netmask): + + + +
+ + 
17def get_ip_network(ip_netmask):
+18    try:
+19        if ip_netmask:
+20            return ip_network(ip_netmask, strict=False)
+21    except Exception:
+22        return None
+
+ + + + +
+
+ +
+ + class + Address(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
26class Address(XMLBaseModel):
+27    name: str = Field(validation_alias="@name")
+28    type: Optional[str] = None
+29    prefix: Optional[str] = None
+30    ip_netmask: Optional[str] = Field(
+31        alias="ip-netmask",
+32        validation_alias=AliasChoices(
+33            AliasPath("ip-netmask", "#text"),
+34            "ip-netmask",
+35        ),
+36        default=None,
+37    )
+38    ip_network: Optional[IPNetwork] = None
+39    ip_range: Optional[str] = Field(alias="ip-range", default=None)
+40    fqdn: Optional[String] = None
+41    tags: List[String] = Field(
+42        validation_alias=AliasPath("tag", "member"), default=None
+43    )
+44
+45    @field_validator("tags", mode="before")
+46    @classmethod
+47    def validate_tags(cls, v) -> List[str]:
+48        if not v:
+49            return []
+50        if not isinstance(v, list):
+51            return [v]
+52        return v
+53
+54    @model_validator(mode="after")
+55    def validate_ip_network(self) -> Self:
+56        if self.ip_network is None:
+57            self.ip_network = get_ip_network(self.ip_netmask)
+58        if not isinstance(self.ip_network, (IPv4Network, IPv6Network)):
+59            self.ip_network = None
+60        return self
+61
+62    @model_validator(mode="after")
+63    def validate_type(self) -> Self:
+64        address_type = None
+65        if self.prefix:
+66            address_type = "prefix"
+67        elif self.ip_netmask:
+68            address_type = "ip-netmask"
+69        elif self.ip_range:
+70            address_type = "ip-range"
+71        elif self.fqdn:
+72            address_type = "fqdn"
+73        self.type = address_type
+74        return self
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ name: str + + +
+ + + + +
+
+
+ type: Optional[str] + + +
+ + + + +
+
+
+ prefix: Optional[str] + + +
+ + + + +
+
+
+ ip_netmask: Optional[str] + + +
+ + + + +
+
+
+ ip_network: Union[ipaddress.IPv4Network, ipaddress.IPv6Network, NoneType] + + +
+ + + + +
+
+
+ ip_range: Optional[str] + + +
+ + + + +
+
+
+ fqdn: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+
@field_validator('tags', mode='before')
+
@classmethod
+ + def + validate_tags( cls, v) -> Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]: + + + +
+ + 
45    @field_validator("tags", mode="before")
+46    @classmethod
+47    def validate_tags(cls, v) -> List[str]:
+48        if not v:
+49            return []
+50        if not isinstance(v, list):
+51            return [v]
+52        return v
+
+ + + + +
+
+ +
+
@model_validator(mode='after')
+ + def + validate_ip_network(self) -> typing_extensions.Self: + + + +
+ + 
54    @model_validator(mode="after")
+55    def validate_ip_network(self) -> Self:
+56        if self.ip_network is None:
+57            self.ip_network = get_ip_network(self.ip_netmask)
+58        if not isinstance(self.ip_network, (IPv4Network, IPv6Network)):
+59            self.ip_network = None
+60        return self
+
+ + + + +
+
+ +
+
@model_validator(mode='after')
+ + def + validate_type(self) -> typing_extensions.Self: + + + +
+ + 
62    @model_validator(mode="after")
+63    def validate_type(self) -> Self:
+64        address_type = None
+65        if self.prefix:
+66            address_type = "prefix"
+67        elif self.ip_netmask:
+68            address_type = "ip-netmask"
+69        elif self.ip_range:
+70            address_type = "ip-range"
+71        elif self.fqdn:
+72            address_type = "fqdn"
+73        self.type = address_type
+74        return self
+
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'prefix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ip_netmask': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='ip-netmask', alias_priority=2, validation_alias=AliasChoices(choices=[AliasPath(path=['ip-netmask', '#text']), 'ip-netmask'])), 'ip_network': FieldInfo(annotation=Union[IPv4Network, IPv6Network, NoneType], required=False, default=None), 'ip_range': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='ip-range', alias_priority=2), 'fqdn': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + def + find_addresses(tree): + + + +
+ + 
77def find_addresses(tree):
+78    # addresses_xml = tree.xpath(".//address/entry")
+79    addresses_xml = tree.xpath("./devices/entry/device-group//address/entry")
+80    address_objects = [Address.from_xml(n) for n in addresses_xml]
+81
+82    addresses = []
+83    subnets = []
+84    for a in address_objects:
+85        network = a.ip_network
+86        # We do not consider ip ranges for now
+87        if not network:
+88            continue
+89        if network.prefixlen == network.max_prefixlen:
+90            addresses.append(a)
+91        else:
+92            subnets.append(a)
+93    return addresses, subnets
+
+ + + + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/devicegroup.html b/public/pa_api/xmlapi/types/config/devicegroup.html new file mode 100644 index 0000000..09fa0d2 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/devicegroup.html @@ -0,0 +1,554 @@ + + + + + + + pa_api.xmlapi.types.config.devicegroup API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.devicegroup

+ + + + + + + 
 1from typing import Optional
+ 2
+ 3from pydantic import AliasPath, ConfigDict, Field
+ 4
+ 5from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+ 6
+ 7from .address import Address
+ 8from .rules import RuleBase
+ 9
+10
+11class DeviceGroup(XMLBaseModel):
+12    """
+13    This is used to parse the output of the running configuration.
+14    """
+15
+16    model_config = ConfigDict(extra="allow")
+17
+18    name: String = Field(validation_alias="@name")
+19    description: String = ""
+20
+21    devices: List[String] = Field(
+22        validation_alias=AliasPath("devices", "entry", "@name"), default_factory=list
+23    )
+24    # devices: List[Device] = Field(
+25    #     validation_alias=AliasPath("devices", "entry"), default_factory=list
+26    # )
+27    addresses: List[Address] = Field(
+28        validation_alias=AliasPath("address", "entry"), default_factory=list
+29    )
+30    post_rulebase: Optional[RuleBase] = Field(
+31        validation_alias="post-rulebase", default=None
+32    )
+33    pre_rulebase: Optional[RuleBase] = Field(
+34        validation_alias="pre-rulebase", default=None
+35    )
+36    # applications: List[Application] = Field(
+37    #     validation_alias=AliasPath("application", "entry"), default_factory=list
+38    # )
+39    tags: List[String] = Field(
+40        validation_alias=AliasPath("tag", "member"), default_factory=list
+41    )
+42
+43    def iter_rulebases(self):
+44        for rulebase in (self.pre_rulebase, self.post_rulebase):
+45            if rulebase is not None:
+46                yield rulebase
+
+ + +
+
+ +
+ + class + DeviceGroup(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
12class DeviceGroup(XMLBaseModel):
+13    """
+14    This is used to parse the output of the running configuration.
+15    """
+16
+17    model_config = ConfigDict(extra="allow")
+18
+19    name: String = Field(validation_alias="@name")
+20    description: String = ""
+21
+22    devices: List[String] = Field(
+23        validation_alias=AliasPath("devices", "entry", "@name"), default_factory=list
+24    )
+25    # devices: List[Device] = Field(
+26    #     validation_alias=AliasPath("devices", "entry"), default_factory=list
+27    # )
+28    addresses: List[Address] = Field(
+29        validation_alias=AliasPath("address", "entry"), default_factory=list
+30    )
+31    post_rulebase: Optional[RuleBase] = Field(
+32        validation_alias="post-rulebase", default=None
+33    )
+34    pre_rulebase: Optional[RuleBase] = Field(
+35        validation_alias="pre-rulebase", default=None
+36    )
+37    # applications: List[Application] = Field(
+38    #     validation_alias=AliasPath("application", "entry"), default_factory=list
+39    # )
+40    tags: List[String] = Field(
+41        validation_alias=AliasPath("tag", "member"), default_factory=list
+42    )
+43
+44    def iter_rulebases(self):
+45        for rulebase in (self.pre_rulebase, self.post_rulebase):
+46            if rulebase is not None:
+47                yield rulebase
+
+ + +

This is used to parse the output of the running configuration.

+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ devices: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ addresses: Annotated[List[pa_api.xmlapi.types.config.address.Address], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ post_rulebase: Optional[pa_api.xmlapi.types.config.rules.rulebase.RuleBase] + + +
+ + + + +
+
+
+ pre_rulebase: Optional[pa_api.xmlapi.types.config.rules.rulebase.RuleBase] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + iter_rulebases(self): + + + +
+ + 
44    def iter_rulebases(self):
+45        for rulebase in (self.pre_rulebase, self.post_rulebase):
+46            if rulebase is not None:
+47                yield rulebase
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'devices': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['devices', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'addresses': FieldInfo(annotation=List[Address], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['address', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'post_rulebase': FieldInfo(annotation=Union[RuleBase, NoneType], required=False, default=None, alias_priority=2, validation_alias='post-rulebase'), 'pre_rulebase': FieldInfo(annotation=Union[RuleBase, NoneType], required=False, default=None, alias_priority=2, validation_alias='pre-rulebase'), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/interface.html b/public/pa_api/xmlapi/types/config/interface.html new file mode 100644 index 0000000..7aa60c3 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/interface.html @@ -0,0 +1,3452 @@ + + + + + + + pa_api.xmlapi.types.config.interface API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.interface

+ + + + + + + 
  1from ipaddress import ip_network
+  2from typing import ClassVar, Iterable, Optional
+  3
+  4from pydantic import AliasPath, ConfigDict, Field
+  5
+  6from pa_api.xmlapi.types.utils import Ip, List, String, XMLBaseModel
+  7
+  8
+  9def get_ip_network(ip_netmask):
+ 10    try:
+ 11        if ip_netmask:
+ 12            return ip_network(ip_netmask, strict=False)
+ 13    except Exception:
+ 14        return None
+ 15
+ 16
+ 17class GenericInterface(XMLBaseModel):
+ 18    model_config = ConfigDict(extra="ignore")
+ 19    inttype: str
+ 20    parent: Optional[str] = None
+ 21    name: str
+ 22    description: String = ""
+ 23    comment: String = ""
+ 24    ip: List[str] = Field(default_factory=list)
+ 25    untagged_sub_interface: Optional[String] = None
+ 26    tags: List[String] = Field(default_factory=list)
+ 27    link_state: Optional[str] = None
+ 28    link_speed: Optional[str] = None
+ 29    link_duplex: Optional[str] = None
+ 30    aggregate_group: Optional[String] = None
+ 31
+ 32
+ 33class Layer2(XMLBaseModel):
+ 34    model_config = ConfigDict(extra="allow")
+ 35    inttype: ClassVar[str] = "layer2"
+ 36
+ 37    name: String = Field(validation_alias="@name", default="")
+ 38    units: List["Layer2"] = Field(
+ 39        alias="units",
+ 40        validation_alias=AliasPath("units", "entry"),
+ 41        default_factory=list,
+ 42    )
+ 43    comment: String = ""
+ 44    tags: List[String] = Field(
+ 45        validation_alias=AliasPath("tag", "member"),
+ 46        default_factory=list,
+ 47    )
+ 48
+ 49    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+ 50        if self.name:
+ 51            dump = self.model_dump()
+ 52            dump.update(
+ 53                {
+ 54                    "inttype": self.inttype,
+ 55                    "parent": parent,
+ 56                }
+ 57            )
+ 58            generic = GenericInterface.model_validate(dump)
+ 59            yield generic
+ 60            parent = self.name
+ 61        for u in self.units:
+ 62            yield from u.flatten(parent)
+ 63
+ 64
+ 65class Layer3(XMLBaseModel):
+ 66    model_config = ConfigDict(extra="allow")
+ 67    inttype: ClassVar[str] = "layer3"
+ 68
+ 69    name: Optional[String] = Field(validation_alias="@name", default=None)
+ 70    description: String = Field(validation_alias="#text", default="")
+ 71    ip: List[Ip] = Field(
+ 72        validation_alias=AliasPath("ip", "entry"), default_factory=list
+ 73    )
+ 74    untagged_sub_interface: Optional[String] = Field(
+ 75        alias="untagged-sub-interface",
+ 76        default=None,
+ 77    )
+ 78    units: List["Layer3"] = Field(
+ 79        alias="units",
+ 80        validation_alias=AliasPath("units", "entry"),
+ 81        default_factory=list,
+ 82    )
+ 83    comment: String = ""
+ 84    tags: List[String] = Field(
+ 85        validation_alias=AliasPath("tag", "member"),
+ 86        default_factory=list,
+ 87    )
+ 88
+ 89    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+ 90        if self.name:
+ 91            dump = self.model_dump()
+ 92            dump.update(
+ 93                {
+ 94                    "inttype": self.inttype,
+ 95                    "parent": parent,
+ 96                }
+ 97            )
+ 98            generic = GenericInterface.model_validate(dump)
+ 99            yield generic
+100            parent = self.name
+101        for u in self.units:
+102            yield from u.flatten(parent)
+103
+104
+105class Vlan(XMLBaseModel):
+106    model_config = ConfigDict(extra="allow")
+107    inttype: ClassVar[str] = "vlan"
+108
+109    name: Optional[String] = Field(validation_alias="@name", default=None)
+110    description: String = Field(validation_alias="#text", default="")
+111    ip: List[Ip] = Field(
+112        validation_alias=AliasPath("ip", "entry"), default_factory=list
+113    )
+114    # untagged_sub_interface: Optional[String] = Field(
+115    #     alias="untagged-sub-interface",
+116    #     default=None,
+117    # )
+118    units: List["Vlan"] = Field(
+119        alias="units",
+120        validation_alias=AliasPath("units", "entry"),
+121        default_factory=list,
+122    )
+123    comment: String = ""
+124    tags: List[String] = Field(
+125        validation_alias=AliasPath("tag", "member"),
+126        default_factory=list,
+127    )
+128
+129    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+130        if self.name:
+131            dump = self.model_dump()
+132            dump.update(
+133                {
+134                    "inttype": self.inttype,
+135                    "parent": parent,
+136                }
+137            )
+138            generic = GenericInterface.model_validate(dump)
+139            yield generic
+140            parent = self.name
+141        for u in self.units:
+142            yield from u.flatten(parent)
+143
+144
+145class Ethernet(XMLBaseModel):
+146    model_config = ConfigDict(extra="allow")
+147    inttype: ClassVar[str] = "ethernet"
+148
+149    name: str = Field(validation_alias="@name")
+150    ip: List[str] = Field(
+151        validation_alias=AliasPath("layer3", "ip", "entry", "@name"),
+152        default_factory=list,
+153    )
+154    description: String = Field(validation_alias="#text", default="")
+155    link_state: Optional[str] = Field(
+156        alias="link-state",
+157        validation_alias=AliasPath("link-state", "#text"),
+158        default=None,
+159    )
+160    link_speed: Optional[str] = Field(
+161        alias="link-speed",
+162        validation_alias=AliasPath("link-speed", "#text"),
+163        default=None,
+164    )
+165    link_duplex: Optional[str] = Field(
+166        alias="link-duplex",
+167        validation_alias=AliasPath("link-duplex", "#text"),
+168        default=None,
+169    )
+170    aggregate_group: Optional[String] = Field(
+171        alias="aggregate-group",
+172        default=None,
+173    )
+174    layer2: Optional[Layer2] = Field(alias="layer2", default=None)
+175    layer3: Optional[Layer3] = Field(alias="layer3", default=None)
+176    tags: List[String] = Field(
+177        validation_alias=AliasPath("tag", "member"),
+178        default_factory=list,
+179    )
+180
+181    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+182        if self.name:
+183            dump = self.model_dump()
+184            dump.update(
+185                {
+186                    "inttype": self.inttype,
+187                    "parent": parent,
+188                }
+189            )
+190            generic = GenericInterface.model_validate(dump)
+191            yield generic
+192            parent = self.name
+193        if self.layer2:
+194            yield from self.layer2.flatten(parent)
+195        if self.layer3:
+196            yield from self.layer3.flatten(parent)
+197
+198    # @model_validator(mode="before")
+199    # @classmethod
+200    # def test(cls, data):
+201    #     print("\n" * 5)
+202    #     print("Ethernet:", data)
+203    #     return data
+204
+205
+206class AggregateEthernet(XMLBaseModel):
+207    model_config = ConfigDict(extra="allow")
+208    inttype: ClassVar[str] = "aggregate"
+209
+210    name: str = Field(validation_alias="@name")
+211    ip: List[str] = Field(
+212        validation_alias=AliasPath("layer3", "ip", "entry", "@name"),
+213        default_factory=list,
+214    )
+215    description: String = Field(validation_alias="#text", default="")
+216    comment: String = ""
+217    units: List["AggregateEthernet"] = Field(
+218        alias="units",
+219        validation_alias=AliasPath("units", "entry"),
+220        default_factory=list,
+221    )
+222    layer2: Optional[Layer2] = Field(alias="layer2", default=None)
+223    layer3: Optional[Layer3] = Field(alias="layer3", default=None)
+224    untagged_sub_interface: Optional[String] = Field(
+225        alias="untagged-sub-interface",
+226        default=None,
+227    )
+228    tags: List[String] = Field(
+229        validation_alias=AliasPath("tag", "member"),
+230        default_factory=list,
+231    )
+232    # @model_validator(mode="before")
+233    # @classmethod
+234    # def test(cls, data):
+235    #     print("\n" * 5)
+236    #     print("AggregateEthernet:", data)
+237    #     return data
+238
+239    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+240        if self.name:
+241            dump = self.model_dump()
+242            dump.update(
+243                {
+244                    "inttype": self.inttype,
+245                    "parent": parent,
+246                }
+247            )
+248            generic = GenericInterface.model_validate(dump)
+249            yield generic
+250            parent = self.name
+251        if self.layer2:
+252            yield from self.layer2.flatten(parent)
+253        if self.layer3:
+254            yield from self.layer3.flatten(parent)
+255
+256
+257class Tunnel(XMLBaseModel):
+258    model_config = ConfigDict(extra="allow")
+259    inttype: ClassVar[str] = "tunnel"
+260
+261    name: str = Field(validation_alias="@name")
+262    units: List["Tunnel"] = Field(
+263        alias="units",
+264        validation_alias=AliasPath("units", "entry"),
+265        default_factory=list,
+266    )
+267    ip: List[str] = Field(
+268        validation_alias=AliasPath("ip", "entry", "@name"),
+269        default_factory=list,
+270    )
+271    interface_management_profile: Optional[String] = Field(
+272        validation_alias="interface-management-profile", default=None
+273    )
+274
+275    comment: Optional[str] = Field(
+276        alias="comment", validation_alias=AliasPath("comment", "#text"), default=None
+277    )
+278    mtu: Optional[str] = Field(
+279        alias="comment", validation_alias=AliasPath("mtu", "#text"), default=None
+280    )
+281
+282    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+283        dump = self.model_dump()
+284        dump.update(
+285            {
+286                "inttype": self.inttype,
+287                "parent": parent,
+288            }
+289        )
+290        generic = GenericInterface.model_validate(dump)
+291        yield generic
+292
+293
+294class Loopback(XMLBaseModel):
+295    model_config = ConfigDict(extra="allow")
+296    inttype: ClassVar[str] = "loopback"
+297
+298    name: str = Field(validation_alias="@name")
+299    description: Optional[String] = Field(validation_alias="#text", default=None)
+300    ip: List[Ip] = Field(
+301        validation_alias=AliasPath("ip", "entry"), default_factory=list
+302    )
+303    comment: Optional[str] = Field(
+304        alias="comment", validation_alias=AliasPath("comment", "#text"), default=None
+305    )
+306    tags: List[String] = Field(
+307        validation_alias=AliasPath("tag", "member"),
+308        default_factory=list,
+309    )
+310
+311    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+312        dump = self.model_dump()
+313        dump.update(
+314            {
+315                "inttype": self.inttype,
+316                "parent": parent,
+317            }
+318        )
+319        generic = GenericInterface.model_validate(dump)
+320        yield generic
+321
+322
+323# https://docs.pydantic.dev/latest/concepts/alias/#aliaspath-and-aliaschoices
+324class Interface(XMLBaseModel):
+325    model_config = ConfigDict(extra="allow")
+326
+327    aggregate_ethernet: List[AggregateEthernet] = Field(
+328        alias="aggregate-ethernet",
+329        validation_alias=AliasPath("aggregate-ethernet", "entry"),
+330        default_factory=list,
+331    )
+332    # entry = Field(alias="entry")
+333    ethernet: List[Ethernet] = Field(
+334        alias="ethernet",
+335        validation_alias=AliasPath("ethernet", "entry"),
+336        default_factory=list,
+337    )
+338    loopback: List[Loopback] = Field(
+339        alias="loopback",
+340        validation_alias=AliasPath("loopback", "units", "entry"),
+341        default_factory=list,
+342    )
+343    vlan: List[Vlan] = Field(
+344        alias="vlan",
+345        validation_alias=AliasPath("vlan", "units", "entry"),
+346        default_factory=list,
+347    )
+348    tunnel: List[Tunnel] = Field(
+349        alias="tunnel",
+350        validation_alias=AliasPath("tunnel", "units", "entry"),
+351        default_factory=list,
+352    )
+353
+354    # ha1 = Field(alias='ha1')
+355    # ha1_backup = Field(alias='ha1-backup')
+356    # ha2 = Field(alias='ha2')
+357    # ha2_backup = Field(alias='ha2-backup')
+358    # ha3 = Field(alias='ha3')
+359    # member = Field(alias='member')
+360    # tunnel = Field(alias='tunnel')
+361
+362    def _flatten(self) -> Iterable[GenericInterface]:
+363        for eth in self.ethernet:
+364            yield from eth.flatten()
+365        for agg in self.aggregate_ethernet:
+366            yield from agg.flatten()
+367        for v in self.vlan:
+368            yield from v.flatten()
+369        for lb in self.loopback:
+370            yield from lb.flatten()
+371
+372    def flatten(self) -> List[GenericInterface]:
+373        return list(self._flatten())
+
+ + +
+
+ +
+ + def + get_ip_network(ip_netmask): + + + +
+ + 
10def get_ip_network(ip_netmask):
+11    try:
+12        if ip_netmask:
+13            return ip_network(ip_netmask, strict=False)
+14    except Exception:
+15        return None
+
+ + + + +
+
+ +
+ + class + GenericInterface(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
18class GenericInterface(XMLBaseModel):
+19    model_config = ConfigDict(extra="ignore")
+20    inttype: str
+21    parent: Optional[str] = None
+22    name: str
+23    description: String = ""
+24    comment: String = ""
+25    ip: List[str] = Field(default_factory=list)
+26    untagged_sub_interface: Optional[String] = None
+27    tags: List[String] = Field(default_factory=list)
+28    link_state: Optional[str] = None
+29    link_speed: Optional[str] = None
+30    link_duplex: Optional[str] = None
+31    aggregate_group: Optional[String] = None
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'ignore'} + + +
+ + + + +
+
+
+ inttype: str + + +
+ + + + +
+
+
+ parent: Optional[str] + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ comment: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ ip: Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ untagged_sub_interface: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+ + + +
+
+ aggregate_group: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ model_fields = + + {'inttype': FieldInfo(annotation=str, required=True), 'parent': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, metadata=[BeforeValidator(func=<function ensure_list>)]), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, metadata=[BeforeValidator(func=<function ensure_list>)]), 'link_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'link_speed': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'link_duplex': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'aggregate_group': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Layer2(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
34class Layer2(XMLBaseModel):
+35    model_config = ConfigDict(extra="allow")
+36    inttype: ClassVar[str] = "layer2"
+37
+38    name: String = Field(validation_alias="@name", default="")
+39    units: List["Layer2"] = Field(
+40        alias="units",
+41        validation_alias=AliasPath("units", "entry"),
+42        default_factory=list,
+43    )
+44    comment: String = ""
+45    tags: List[String] = Field(
+46        validation_alias=AliasPath("tag", "member"),
+47        default_factory=list,
+48    )
+49
+50    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+51        if self.name:
+52            dump = self.model_dump()
+53            dump.update(
+54                {
+55                    "inttype": self.inttype,
+56                    "parent": parent,
+57                }
+58            )
+59            generic = GenericInterface.model_validate(dump)
+60            yield generic
+61            parent = self.name
+62        for u in self.units:
+63            yield from u.flatten(parent)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'layer2' + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ units: Annotated[List[Layer2], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ comment: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
50    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+51        if self.name:
+52            dump = self.model_dump()
+53            dump.update(
+54                {
+55                    "inttype": self.inttype,
+56                    "parent": parent,
+57                }
+58            )
+59            generic = GenericInterface.model_validate(dump)
+60            yield generic
+61            parent = self.name
+62        for u in self.units:
+63            yield from u.flatten(parent)
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'units': FieldInfo(annotation=List[Layer2], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Layer3(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 66class Layer3(XMLBaseModel):
+ 67    model_config = ConfigDict(extra="allow")
+ 68    inttype: ClassVar[str] = "layer3"
+ 69
+ 70    name: Optional[String] = Field(validation_alias="@name", default=None)
+ 71    description: String = Field(validation_alias="#text", default="")
+ 72    ip: List[Ip] = Field(
+ 73        validation_alias=AliasPath("ip", "entry"), default_factory=list
+ 74    )
+ 75    untagged_sub_interface: Optional[String] = Field(
+ 76        alias="untagged-sub-interface",
+ 77        default=None,
+ 78    )
+ 79    units: List["Layer3"] = Field(
+ 80        alias="units",
+ 81        validation_alias=AliasPath("units", "entry"),
+ 82        default_factory=list,
+ 83    )
+ 84    comment: String = ""
+ 85    tags: List[String] = Field(
+ 86        validation_alias=AliasPath("tag", "member"),
+ 87        default_factory=list,
+ 88    )
+ 89
+ 90    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+ 91        if self.name:
+ 92            dump = self.model_dump()
+ 93            dump.update(
+ 94                {
+ 95                    "inttype": self.inttype,
+ 96                    "parent": parent,
+ 97                }
+ 98            )
+ 99            generic = GenericInterface.model_validate(dump)
+100            yield generic
+101            parent = self.name
+102        for u in self.units:
+103            yield from u.flatten(parent)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'layer3' + + +
+ + + + +
+
+
+ name: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ ip: Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ untagged_sub_interface: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ units: Annotated[List[Layer3], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ comment: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
 90    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+ 91        if self.name:
+ 92            dump = self.model_dump()
+ 93            dump.update(
+ 94                {
+ 95                    "inttype": self.inttype,
+ 96                    "parent": parent,
+ 97                }
+ 98            )
+ 99            generic = GenericInterface.model_validate(dump)
+100            yield generic
+101            parent = self.name
+102        for u in self.units:
+103            yield from u.flatten(parent)
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='untagged-sub-interface', alias_priority=2), 'units': FieldInfo(annotation=List[Layer3], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Vlan(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
106class Vlan(XMLBaseModel):
+107    model_config = ConfigDict(extra="allow")
+108    inttype: ClassVar[str] = "vlan"
+109
+110    name: Optional[String] = Field(validation_alias="@name", default=None)
+111    description: String = Field(validation_alias="#text", default="")
+112    ip: List[Ip] = Field(
+113        validation_alias=AliasPath("ip", "entry"), default_factory=list
+114    )
+115    # untagged_sub_interface: Optional[String] = Field(
+116    #     alias="untagged-sub-interface",
+117    #     default=None,
+118    # )
+119    units: List["Vlan"] = Field(
+120        alias="units",
+121        validation_alias=AliasPath("units", "entry"),
+122        default_factory=list,
+123    )
+124    comment: String = ""
+125    tags: List[String] = Field(
+126        validation_alias=AliasPath("tag", "member"),
+127        default_factory=list,
+128    )
+129
+130    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+131        if self.name:
+132            dump = self.model_dump()
+133            dump.update(
+134                {
+135                    "inttype": self.inttype,
+136                    "parent": parent,
+137                }
+138            )
+139            generic = GenericInterface.model_validate(dump)
+140            yield generic
+141            parent = self.name
+142        for u in self.units:
+143            yield from u.flatten(parent)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'vlan' + + +
+ + + + +
+
+
+ name: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ ip: Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ units: Annotated[List[Vlan], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ comment: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
130    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+131        if self.name:
+132            dump = self.model_dump()
+133            dump.update(
+134                {
+135                    "inttype": self.inttype,
+136                    "parent": parent,
+137                }
+138            )
+139            generic = GenericInterface.model_validate(dump)
+140            yield generic
+141            parent = self.name
+142        for u in self.units:
+143            yield from u.flatten(parent)
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'units': FieldInfo(annotation=List[Vlan], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Ethernet(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
146class Ethernet(XMLBaseModel):
+147    model_config = ConfigDict(extra="allow")
+148    inttype: ClassVar[str] = "ethernet"
+149
+150    name: str = Field(validation_alias="@name")
+151    ip: List[str] = Field(
+152        validation_alias=AliasPath("layer3", "ip", "entry", "@name"),
+153        default_factory=list,
+154    )
+155    description: String = Field(validation_alias="#text", default="")
+156    link_state: Optional[str] = Field(
+157        alias="link-state",
+158        validation_alias=AliasPath("link-state", "#text"),
+159        default=None,
+160    )
+161    link_speed: Optional[str] = Field(
+162        alias="link-speed",
+163        validation_alias=AliasPath("link-speed", "#text"),
+164        default=None,
+165    )
+166    link_duplex: Optional[str] = Field(
+167        alias="link-duplex",
+168        validation_alias=AliasPath("link-duplex", "#text"),
+169        default=None,
+170    )
+171    aggregate_group: Optional[String] = Field(
+172        alias="aggregate-group",
+173        default=None,
+174    )
+175    layer2: Optional[Layer2] = Field(alias="layer2", default=None)
+176    layer3: Optional[Layer3] = Field(alias="layer3", default=None)
+177    tags: List[String] = Field(
+178        validation_alias=AliasPath("tag", "member"),
+179        default_factory=list,
+180    )
+181
+182    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+183        if self.name:
+184            dump = self.model_dump()
+185            dump.update(
+186                {
+187                    "inttype": self.inttype,
+188                    "parent": parent,
+189                }
+190            )
+191            generic = GenericInterface.model_validate(dump)
+192            yield generic
+193            parent = self.name
+194        if self.layer2:
+195            yield from self.layer2.flatten(parent)
+196        if self.layer3:
+197            yield from self.layer3.flatten(parent)
+198
+199    # @model_validator(mode="before")
+200    # @classmethod
+201    # def test(cls, data):
+202    #     print("\n" * 5)
+203    #     print("Ethernet:", data)
+204    #     return data
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'ethernet' + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ ip: Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+ + + +
+
+ aggregate_group: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ layer2: Optional[Layer2] + + +
+ + + + +
+
+
+ layer3: Optional[Layer3] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
182    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+183        if self.name:
+184            dump = self.model_dump()
+185            dump.update(
+186                {
+187                    "inttype": self.inttype,
+188                    "parent": parent,
+189                }
+190            )
+191            generic = GenericInterface.model_validate(dump)
+192            yield generic
+193            parent = self.name
+194        if self.layer2:
+195            yield from self.layer2.flatten(parent)
+196        if self.layer3:
+197            yield from self.layer3.flatten(parent)
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'link_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-state', alias_priority=2, validation_alias=AliasPath(path=['link-state', '#text'])), 'link_speed': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-speed', alias_priority=2, validation_alias=AliasPath(path=['link-speed', '#text'])), 'link_duplex': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-duplex', alias_priority=2, validation_alias=AliasPath(path=['link-duplex', '#text'])), 'aggregate_group': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='aggregate-group', alias_priority=2), 'layer2': FieldInfo(annotation=Union[Layer2, NoneType], required=False, default=None, alias='layer2', alias_priority=2), 'layer3': FieldInfo(annotation=Union[Layer3, NoneType], required=False, default=None, alias='layer3', alias_priority=2), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + AggregateEthernet(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
207class AggregateEthernet(XMLBaseModel):
+208    model_config = ConfigDict(extra="allow")
+209    inttype: ClassVar[str] = "aggregate"
+210
+211    name: str = Field(validation_alias="@name")
+212    ip: List[str] = Field(
+213        validation_alias=AliasPath("layer3", "ip", "entry", "@name"),
+214        default_factory=list,
+215    )
+216    description: String = Field(validation_alias="#text", default="")
+217    comment: String = ""
+218    units: List["AggregateEthernet"] = Field(
+219        alias="units",
+220        validation_alias=AliasPath("units", "entry"),
+221        default_factory=list,
+222    )
+223    layer2: Optional[Layer2] = Field(alias="layer2", default=None)
+224    layer3: Optional[Layer3] = Field(alias="layer3", default=None)
+225    untagged_sub_interface: Optional[String] = Field(
+226        alias="untagged-sub-interface",
+227        default=None,
+228    )
+229    tags: List[String] = Field(
+230        validation_alias=AliasPath("tag", "member"),
+231        default_factory=list,
+232    )
+233    # @model_validator(mode="before")
+234    # @classmethod
+235    # def test(cls, data):
+236    #     print("\n" * 5)
+237    #     print("AggregateEthernet:", data)
+238    #     return data
+239
+240    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+241        if self.name:
+242            dump = self.model_dump()
+243            dump.update(
+244                {
+245                    "inttype": self.inttype,
+246                    "parent": parent,
+247                }
+248            )
+249            generic = GenericInterface.model_validate(dump)
+250            yield generic
+251            parent = self.name
+252        if self.layer2:
+253            yield from self.layer2.flatten(parent)
+254        if self.layer3:
+255            yield from self.layer3.flatten(parent)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'aggregate' + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ ip: Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ comment: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ units: Annotated[List[AggregateEthernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ layer2: Optional[Layer2] + + +
+ + + + +
+
+
+ layer3: Optional[Layer3] + + +
+ + + + +
+
+
+ untagged_sub_interface: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
240    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+241        if self.name:
+242            dump = self.model_dump()
+243            dump.update(
+244                {
+245                    "inttype": self.inttype,
+246                    "parent": parent,
+247                }
+248            )
+249            generic = GenericInterface.model_validate(dump)
+250            yield generic
+251            parent = self.name
+252        if self.layer2:
+253            yield from self.layer2.flatten(parent)
+254        if self.layer3:
+255            yield from self.layer3.flatten(parent)
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'units': FieldInfo(annotation=List[AggregateEthernet], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'layer2': FieldInfo(annotation=Union[Layer2, NoneType], required=False, default=None, alias='layer2', alias_priority=2), 'layer3': FieldInfo(annotation=Union[Layer3, NoneType], required=False, default=None, alias='layer3', alias_priority=2), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='untagged-sub-interface', alias_priority=2), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Tunnel(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
258class Tunnel(XMLBaseModel):
+259    model_config = ConfigDict(extra="allow")
+260    inttype: ClassVar[str] = "tunnel"
+261
+262    name: str = Field(validation_alias="@name")
+263    units: List["Tunnel"] = Field(
+264        alias="units",
+265        validation_alias=AliasPath("units", "entry"),
+266        default_factory=list,
+267    )
+268    ip: List[str] = Field(
+269        validation_alias=AliasPath("ip", "entry", "@name"),
+270        default_factory=list,
+271    )
+272    interface_management_profile: Optional[String] = Field(
+273        validation_alias="interface-management-profile", default=None
+274    )
+275
+276    comment: Optional[str] = Field(
+277        alias="comment", validation_alias=AliasPath("comment", "#text"), default=None
+278    )
+279    mtu: Optional[str] = Field(
+280        alias="comment", validation_alias=AliasPath("mtu", "#text"), default=None
+281    )
+282
+283    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+284        dump = self.model_dump()
+285        dump.update(
+286            {
+287                "inttype": self.inttype,
+288                "parent": parent,
+289            }
+290        )
+291        generic = GenericInterface.model_validate(dump)
+292        yield generic
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'tunnel' + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ units: Annotated[List[Tunnel], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ ip: Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ interface_management_profile: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ comment: Optional[str] + + +
+ + + + +
+
+
+ mtu: Optional[str] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
283    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+284        dump = self.model_dump()
+285        dump.update(
+286            {
+287                "inttype": self.inttype,
+288                "parent": parent,
+289            }
+290        )
+291        generic = GenericInterface.model_validate(dump)
+292        yield generic
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'units': FieldInfo(annotation=List[Tunnel], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'interface_management_profile': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='interface-management-profile'), 'comment': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['comment', '#text'])), 'mtu': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['mtu', '#text']))} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Loopback(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
295class Loopback(XMLBaseModel):
+296    model_config = ConfigDict(extra="allow")
+297    inttype: ClassVar[str] = "loopback"
+298
+299    name: str = Field(validation_alias="@name")
+300    description: Optional[String] = Field(validation_alias="#text", default=None)
+301    ip: List[Ip] = Field(
+302        validation_alias=AliasPath("ip", "entry"), default_factory=list
+303    )
+304    comment: Optional[str] = Field(
+305        alias="comment", validation_alias=AliasPath("comment", "#text"), default=None
+306    )
+307    tags: List[String] = Field(
+308        validation_alias=AliasPath("tag", "member"),
+309        default_factory=list,
+310    )
+311
+312    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+313        dump = self.model_dump()
+314        dump.update(
+315            {
+316                "inttype": self.inttype,
+317                "parent": parent,
+318            }
+319        )
+320        generic = GenericInterface.model_validate(dump)
+321        yield generic
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ inttype: ClassVar[str] = +'loopback' + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ description: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ ip: Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ comment: Optional[str] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self, parent=None) -> Iterable[GenericInterface]: + + + +
+ + 
312    def flatten(self, parent=None) -> Iterable[GenericInterface]:
+313        dump = self.model_dump()
+314        dump.update(
+315            {
+316                "inttype": self.inttype,
+317                "parent": parent,
+318            }
+319        )
+320        generic = GenericInterface.model_validate(dump)
+321        yield generic
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='#text'), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['comment', '#text'])), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Interface(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
325class Interface(XMLBaseModel):
+326    model_config = ConfigDict(extra="allow")
+327
+328    aggregate_ethernet: List[AggregateEthernet] = Field(
+329        alias="aggregate-ethernet",
+330        validation_alias=AliasPath("aggregate-ethernet", "entry"),
+331        default_factory=list,
+332    )
+333    # entry = Field(alias="entry")
+334    ethernet: List[Ethernet] = Field(
+335        alias="ethernet",
+336        validation_alias=AliasPath("ethernet", "entry"),
+337        default_factory=list,
+338    )
+339    loopback: List[Loopback] = Field(
+340        alias="loopback",
+341        validation_alias=AliasPath("loopback", "units", "entry"),
+342        default_factory=list,
+343    )
+344    vlan: List[Vlan] = Field(
+345        alias="vlan",
+346        validation_alias=AliasPath("vlan", "units", "entry"),
+347        default_factory=list,
+348    )
+349    tunnel: List[Tunnel] = Field(
+350        alias="tunnel",
+351        validation_alias=AliasPath("tunnel", "units", "entry"),
+352        default_factory=list,
+353    )
+354
+355    # ha1 = Field(alias='ha1')
+356    # ha1_backup = Field(alias='ha1-backup')
+357    # ha2 = Field(alias='ha2')
+358    # ha2_backup = Field(alias='ha2-backup')
+359    # ha3 = Field(alias='ha3')
+360    # member = Field(alias='member')
+361    # tunnel = Field(alias='tunnel')
+362
+363    def _flatten(self) -> Iterable[GenericInterface]:
+364        for eth in self.ethernet:
+365            yield from eth.flatten()
+366        for agg in self.aggregate_ethernet:
+367            yield from agg.flatten()
+368        for v in self.vlan:
+369            yield from v.flatten()
+370        for lb in self.loopback:
+371            yield from lb.flatten()
+372
+373    def flatten(self) -> List[GenericInterface]:
+374        return list(self._flatten())
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ aggregate_ethernet: Annotated[List[AggregateEthernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ ethernet: Annotated[List[Ethernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ loopback: Annotated[List[Loopback], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ vlan: Annotated[List[Vlan], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ tunnel: Annotated[List[Tunnel], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ + def + flatten( self) -> Annotated[List[GenericInterface], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]: + + + +
+ + 
373    def flatten(self) -> List[GenericInterface]:
+374        return list(self._flatten())
+
+ + + + +
+
+
+ model_fields = + + {'aggregate_ethernet': FieldInfo(annotation=List[AggregateEthernet], required=False, default_factory=list, alias='aggregate-ethernet', alias_priority=2, validation_alias=AliasPath(path=['aggregate-ethernet', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'ethernet': FieldInfo(annotation=List[Ethernet], required=False, default_factory=list, alias='ethernet', alias_priority=2, validation_alias=AliasPath(path=['ethernet', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'loopback': FieldInfo(annotation=List[Loopback], required=False, default_factory=list, alias='loopback', alias_priority=2, validation_alias=AliasPath(path=['loopback', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'vlan': FieldInfo(annotation=List[Vlan], required=False, default_factory=list, alias='vlan', alias_priority=2, validation_alias=AliasPath(path=['vlan', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'tunnel': FieldInfo(annotation=List[Tunnel], required=False, default_factory=list, alias='tunnel', alias_priority=2, validation_alias=AliasPath(path=['tunnel', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/routing.html b/public/pa_api/xmlapi/types/config/routing.html new file mode 100644 index 0000000..9d43dcf --- /dev/null +++ b/public/pa_api/xmlapi/types/config/routing.html @@ -0,0 +1,243 @@ + + + + + + + pa_api.xmlapi.types.config.routing API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.routing

+ + + + + + + 
1from . import routing_table
+2from .routing_table import RoutingTable
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/routing/routing_table.html b/public/pa_api/xmlapi/types/config/routing/routing_table.html new file mode 100644 index 0000000..186c13c --- /dev/null +++ b/public/pa_api/xmlapi/types/config/routing/routing_table.html @@ -0,0 +1,934 @@ + + + + + + + pa_api.xmlapi.types.config.routing.routing_table API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.routing.routing_table

+ + + + + + + 
 1from typing import Optional
+ 2
+ 3from pydantic import AliasPath, ConfigDict, Field
+ 4
+ 5from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+ 6
+ 7
+ 8class NextHop(XMLBaseModel):
+ 9    model_config = ConfigDict(extra="ignore")
+10
+11    ip_address: Optional[String] = Field(validation_alias="ip-address", default=None)
+12
+13
+14class StaticRoute(XMLBaseModel):
+15    model_config = ConfigDict(extra="ignore")
+16
+17    name: String = Field(validation_alias="@name")
+18    nexthop: Optional[NextHop] = Field(validation_alias="nexthop", default=None)
+19    interface: Optional[String] = Field(validation_alias="interface", default=None)
+20    destination: String = Field(validation_alias="destination")
+21
+22
+23class IPv4RoutingTable(XMLBaseModel):
+24    model_config = ConfigDict(extra="ignore")
+25
+26    static_routes: List[StaticRoute] = Field(
+27        validation_alias=AliasPath("static-route", "entry")
+28    )
+29
+30
+31class RoutingTable(XMLBaseModel):
+32    model_config = ConfigDict(extra="ignore")
+33
+34    ip: IPv4RoutingTable = Field(validation_alias="ip")
+
+ + +
+
+ +
+ + class + NextHop(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 9class NextHop(XMLBaseModel):
+10    model_config = ConfigDict(extra="ignore")
+11
+12    ip_address: Optional[String] = Field(validation_alias="ip-address", default=None)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'ignore'} + + +
+ + + + +
+
+
+ ip_address: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ model_fields = + + {'ip_address': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='ip-address')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + StaticRoute(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
15class StaticRoute(XMLBaseModel):
+16    model_config = ConfigDict(extra="ignore")
+17
+18    name: String = Field(validation_alias="@name")
+19    nexthop: Optional[NextHop] = Field(validation_alias="nexthop", default=None)
+20    interface: Optional[String] = Field(validation_alias="interface", default=None)
+21    destination: String = Field(validation_alias="destination")
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'ignore'} + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ nexthop: Optional[NextHop] + + +
+ + + + +
+
+
+ interface: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ destination: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'nexthop': FieldInfo(annotation=Union[NextHop, NoneType], required=False, default=None, alias_priority=2, validation_alias='nexthop'), 'interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='interface'), 'destination': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='destination', metadata=[BeforeValidator(func=<function ensure_str>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + IPv4RoutingTable(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
24class IPv4RoutingTable(XMLBaseModel):
+25    model_config = ConfigDict(extra="ignore")
+26
+27    static_routes: List[StaticRoute] = Field(
+28        validation_alias=AliasPath("static-route", "entry")
+29    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'ignore'} + + +
+ + + + +
+
+
+ static_routes: Annotated[List[StaticRoute], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ model_fields = + + {'static_routes': FieldInfo(annotation=List[StaticRoute], required=True, alias_priority=2, validation_alias=AliasPath(path=['static-route', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + RoutingTable(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
32class RoutingTable(XMLBaseModel):
+33    model_config = ConfigDict(extra="ignore")
+34
+35    ip: IPv4RoutingTable = Field(validation_alias="ip")
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'ignore'} + + +
+ + + + +
+
+
+ ip: IPv4RoutingTable + + +
+ + + + +
+
+
+ model_fields = + + {'ip': FieldInfo(annotation=IPv4RoutingTable, required=True, alias_priority=2, validation_alias='ip')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/rules.html b/public/pa_api/xmlapi/types/config/rules.html new file mode 100644 index 0000000..cc8a0b2 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/rules.html @@ -0,0 +1,247 @@ + + + + + + + pa_api.xmlapi.types.config.rules API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.rules

+ + + + + + + 
1from . import nat, rulebase, security
+2from .nat import NAT
+3from .rulebase import RuleBase
+4from .security import Security
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/rules/nat.html b/public/pa_api/xmlapi/types/config/rules/nat.html new file mode 100644 index 0000000..841fe44 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/rules/nat.html @@ -0,0 +1,1778 @@ + + + + + + + pa_api.xmlapi.types.config.rules.nat API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.rules.nat

+ + + + + + + 
  1import typing
+  2from itertools import chain
+  3from typing import Optional, Union
+  4
+  5from pydantic import AliasPath, Field
+  6
+  7from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+  8
+  9
+ 10class DynamicIPAndPort(XMLBaseModel):
+ 11    translated_address: List[String] = Field(
+ 12        validation_alias="translated-address", default=None
+ 13    )
+ 14    ip: Optional[String] = Field(
+ 15        validation_alias=AliasPath("interface-address", "ip"), default=None
+ 16    )
+ 17    interface: Optional[String] = Field(
+ 18        validation_alias=AliasPath("interface-address", "interface"), default=None
+ 19    )
+ 20
+ 21
+ 22class DynamicIP(XMLBaseModel):
+ 23    translated_address: List[String] = Field(
+ 24        validation_alias="translated-address", default=None
+ 25    )
+ 26
+ 27
+ 28class StaticIP(XMLBaseModel):
+ 29    translated_address: String = Field(validation_alias="translated-address")
+ 30
+ 31
+ 32class SourceTranslation(XMLBaseModel):
+ 33    dynamic_ip_and_port: Optional[DynamicIPAndPort] = Field(
+ 34        validation_alias="dynamic-ip-and-port", default=None
+ 35    )
+ 36    dynamic_ip: Optional[DynamicIP] = Field(validation_alias="dynamic-ip", default=None)
+ 37    static_ip: Optional[StaticIP] = Field(validation_alias="static-ip", default=None)
+ 38
+ 39    @property
+ 40    def translation(self) -> Union[DynamicIPAndPort, DynamicIP, StaticIP]:
+ 41        for trans in (self.dynamic_ip_and_port, self.dynamic_ip, self.static_ip):
+ 42            if trans is not None:
+ 43                return trans
+ 44        raise Exception("Invalid sourc translation")
+ 45
+ 46    @property
+ 47    def translated_address(self) -> typing.List[str]:
+ 48        trans = self.translation.translated_address
+ 49        if isinstance(trans, str):
+ 50            return [trans]
+ 51        return trans
+ 52
+ 53    @property
+ 54    def type(self) -> str:
+ 55        if self.static_ip is not None:
+ 56            return "static-ip"
+ 57        if self.dynamic_ip is not None:
+ 58            return "dynamic-ip"
+ 59        if self.dynamic_ip_and_port is not None:
+ 60            return "dynamic-ip-and-port"
+ 61        raise Exception("Invalid sourc translation")
+ 62
+ 63
+ 64class DestinationTranslation(XMLBaseModel):
+ 65    translated_address: Optional[String] = Field(
+ 66        validation_alias=AliasPath("translated-address", "#text"), default=None
+ 67    )
+ 68    translated_port: Optional[int] = Field(
+ 69        validation_alias=AliasPath("translated-port", "#text"), default=None
+ 70    )
+ 71
+ 72
+ 73class NAT(XMLBaseModel):
+ 74    name: String = Field(validation_alias="@name")
+ 75    uuid: String = Field(validation_alias="@uuid")
+ 76    disabled: Optional[bool] = None
+ 77    description: String = ""
+ 78    group_tag: Optional[String] = Field(validation_alias="group-tag", default=None)
+ 79    tags: List[String] = Field(
+ 80        validation_alias="tag",
+ 81        default_factory=list,
+ 82    )
+ 83    services: List[String] = Field(validation_alias="service", default_factory=list)
+ 84
+ 85    source_translation: Optional[SourceTranslation] = Field(
+ 86        validation_alias="source-translation", default=None
+ 87    )
+ 88    destination_translation: Optional[DestinationTranslation] = Field(
+ 89        validation_alias="destination-translation", default=None
+ 90    )
+ 91
+ 92    sources: List[String] = Field(
+ 93        validation_alias="source",
+ 94        default_factory=list,
+ 95    )
+ 96    destinations: List[String] = Field(
+ 97        validation_alias="destination",
+ 98        default_factory=list,
+ 99    )
+100    to: List[String] = Field(
+101        validation_alias="to",
+102        default_factory=list,
+103    )
+104    from_: List[String] = Field(
+105        validation_alias="from",
+106        default_factory=list,
+107    )
+108
+109    @property
+110    def translated_src_address(self) -> typing.List[str]:
+111        if not self.source_translation:
+112            return []
+113        return self.source_translation.translated_address
+114
+115    @property
+116    def translated_dst_address(self) -> typing.List[str]:
+117        if not self.destination_translation:
+118            return []
+119        translated = self.destination_translation.translated_address
+120        if not translated:
+121            return []
+122        return [translated]
+123
+124    @property
+125    def members(self):
+126        return set(
+127            chain(
+128                self.to,
+129                self.from_,
+130                self.sources,
+131                self.destination_translation,
+132                self.translated_src_address,
+133                self.translated_dst_address,
+134            )
+135        )
+
+ + +
+
+ +
+ + class + DynamicIPAndPort(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
11class DynamicIPAndPort(XMLBaseModel):
+12    translated_address: List[String] = Field(
+13        validation_alias="translated-address", default=None
+14    )
+15    ip: Optional[String] = Field(
+16        validation_alias=AliasPath("interface-address", "ip"), default=None
+17    )
+18    interface: Optional[String] = Field(
+19        validation_alias=AliasPath("interface-address", "interface"), default=None
+20    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ translated_address: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ ip: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ interface: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'translated_address': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_list>)]), 'ip': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['interface-address', 'ip'])), 'interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['interface-address', 'interface']))} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + DynamicIP(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
23class DynamicIP(XMLBaseModel):
+24    translated_address: List[String] = Field(
+25        validation_alias="translated-address", default=None
+26    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ translated_address: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'translated_address': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + StaticIP(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
29class StaticIP(XMLBaseModel):
+30    translated_address: String = Field(validation_alias="translated-address")
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ translated_address: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'translated_address': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_str>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + SourceTranslation(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
33class SourceTranslation(XMLBaseModel):
+34    dynamic_ip_and_port: Optional[DynamicIPAndPort] = Field(
+35        validation_alias="dynamic-ip-and-port", default=None
+36    )
+37    dynamic_ip: Optional[DynamicIP] = Field(validation_alias="dynamic-ip", default=None)
+38    static_ip: Optional[StaticIP] = Field(validation_alias="static-ip", default=None)
+39
+40    @property
+41    def translation(self) -> Union[DynamicIPAndPort, DynamicIP, StaticIP]:
+42        for trans in (self.dynamic_ip_and_port, self.dynamic_ip, self.static_ip):
+43            if trans is not None:
+44                return trans
+45        raise Exception("Invalid sourc translation")
+46
+47    @property
+48    def translated_address(self) -> typing.List[str]:
+49        trans = self.translation.translated_address
+50        if isinstance(trans, str):
+51            return [trans]
+52        return trans
+53
+54    @property
+55    def type(self) -> str:
+56        if self.static_ip is not None:
+57            return "static-ip"
+58        if self.dynamic_ip is not None:
+59            return "dynamic-ip"
+60        if self.dynamic_ip_and_port is not None:
+61            return "dynamic-ip-and-port"
+62        raise Exception("Invalid sourc translation")
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ dynamic_ip_and_port: Optional[DynamicIPAndPort] + + +
+ + + + +
+
+
+ dynamic_ip: Optional[DynamicIP] + + +
+ + + + +
+
+
+ static_ip: Optional[StaticIP] + + +
+ + + + +
+
+ +
+ translation: Union[DynamicIPAndPort, DynamicIP, StaticIP] + + + +
+ + 
40    @property
+41    def translation(self) -> Union[DynamicIPAndPort, DynamicIP, StaticIP]:
+42        for trans in (self.dynamic_ip_and_port, self.dynamic_ip, self.static_ip):
+43            if trans is not None:
+44                return trans
+45        raise Exception("Invalid sourc translation")
+
+ + + + +
+
+ +
+ translated_address: List[str] + + + +
+ + 
47    @property
+48    def translated_address(self) -> typing.List[str]:
+49        trans = self.translation.translated_address
+50        if isinstance(trans, str):
+51            return [trans]
+52        return trans
+
+ + + + +
+
+ +
+ type: str + + + +
+ + 
54    @property
+55    def type(self) -> str:
+56        if self.static_ip is not None:
+57            return "static-ip"
+58        if self.dynamic_ip is not None:
+59            return "dynamic-ip"
+60        if self.dynamic_ip_and_port is not None:
+61            return "dynamic-ip-and-port"
+62        raise Exception("Invalid sourc translation")
+
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'dynamic_ip_and_port': FieldInfo(annotation=Union[DynamicIPAndPort, NoneType], required=False, default=None, alias_priority=2, validation_alias='dynamic-ip-and-port'), 'dynamic_ip': FieldInfo(annotation=Union[DynamicIP, NoneType], required=False, default=None, alias_priority=2, validation_alias='dynamic-ip'), 'static_ip': FieldInfo(annotation=Union[StaticIP, NoneType], required=False, default=None, alias_priority=2, validation_alias='static-ip')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + DestinationTranslation(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
65class DestinationTranslation(XMLBaseModel):
+66    translated_address: Optional[String] = Field(
+67        validation_alias=AliasPath("translated-address", "#text"), default=None
+68    )
+69    translated_port: Optional[int] = Field(
+70        validation_alias=AliasPath("translated-port", "#text"), default=None
+71    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ translated_address: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ translated_port: Optional[int] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'translated_address': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['translated-address', '#text'])), 'translated_port': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['translated-port', '#text']))} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + NAT(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 74class NAT(XMLBaseModel):
+ 75    name: String = Field(validation_alias="@name")
+ 76    uuid: String = Field(validation_alias="@uuid")
+ 77    disabled: Optional[bool] = None
+ 78    description: String = ""
+ 79    group_tag: Optional[String] = Field(validation_alias="group-tag", default=None)
+ 80    tags: List[String] = Field(
+ 81        validation_alias="tag",
+ 82        default_factory=list,
+ 83    )
+ 84    services: List[String] = Field(validation_alias="service", default_factory=list)
+ 85
+ 86    source_translation: Optional[SourceTranslation] = Field(
+ 87        validation_alias="source-translation", default=None
+ 88    )
+ 89    destination_translation: Optional[DestinationTranslation] = Field(
+ 90        validation_alias="destination-translation", default=None
+ 91    )
+ 92
+ 93    sources: List[String] = Field(
+ 94        validation_alias="source",
+ 95        default_factory=list,
+ 96    )
+ 97    destinations: List[String] = Field(
+ 98        validation_alias="destination",
+ 99        default_factory=list,
+100    )
+101    to: List[String] = Field(
+102        validation_alias="to",
+103        default_factory=list,
+104    )
+105    from_: List[String] = Field(
+106        validation_alias="from",
+107        default_factory=list,
+108    )
+109
+110    @property
+111    def translated_src_address(self) -> typing.List[str]:
+112        if not self.source_translation:
+113            return []
+114        return self.source_translation.translated_address
+115
+116    @property
+117    def translated_dst_address(self) -> typing.List[str]:
+118        if not self.destination_translation:
+119            return []
+120        translated = self.destination_translation.translated_address
+121        if not translated:
+122            return []
+123        return [translated]
+124
+125    @property
+126    def members(self):
+127        return set(
+128            chain(
+129                self.to,
+130                self.from_,
+131                self.sources,
+132                self.destination_translation,
+133                self.translated_src_address,
+134                self.translated_dst_address,
+135            )
+136        )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ uuid: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ disabled: Optional[bool] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ group_tag: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ services: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ source_translation: Optional[SourceTranslation] + + +
+ + + + +
+
+
+ destination_translation: Optional[DestinationTranslation] + + +
+ + + + +
+
+
+ sources: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ destinations: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ to: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ from_: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+ +
+ translated_src_address: List[str] + + + +
+ + 
110    @property
+111    def translated_src_address(self) -> typing.List[str]:
+112        if not self.source_translation:
+113            return []
+114        return self.source_translation.translated_address
+
+ + + + +
+
+ +
+ translated_dst_address: List[str] + + + +
+ + 
116    @property
+117    def translated_dst_address(self) -> typing.List[str]:
+118        if not self.destination_translation:
+119            return []
+120        translated = self.destination_translation.translated_address
+121        if not translated:
+122            return []
+123        return [translated]
+
+ + + + +
+
+ +
+ members + + + +
+ + 
125    @property
+126    def members(self):
+127        return set(
+128            chain(
+129                self.to,
+130                self.from_,
+131                self.sources,
+132                self.destination_translation,
+133                self.translated_src_address,
+134                self.translated_dst_address,
+135            )
+136        )
+
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@uuid', metadata=[BeforeValidator(func=<function ensure_str>)]), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'group_tag': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='group-tag'), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='tag', metadata=[BeforeValidator(func=<function ensure_list>)]), 'services': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='service', metadata=[BeforeValidator(func=<function ensure_list>)]), 'source_translation': FieldInfo(annotation=Union[SourceTranslation, NoneType], required=False, default=None, alias_priority=2, validation_alias='source-translation'), 'destination_translation': FieldInfo(annotation=Union[DestinationTranslation, NoneType], required=False, default=None, alias_priority=2, validation_alias='destination-translation'), 'sources': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='source', metadata=[BeforeValidator(func=<function ensure_list>)]), 'destinations': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='destination', metadata=[BeforeValidator(func=<function ensure_list>)]), 'to': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='to', metadata=[BeforeValidator(func=<function ensure_list>)]), 'from_': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='from', metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/rules/rulebase.html b/public/pa_api/xmlapi/types/config/rules/rulebase.html new file mode 100644 index 0000000..afd6326 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/rules/rulebase.html @@ -0,0 +1,434 @@ + + + + + + + pa_api.xmlapi.types.config.rules.rulebase API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.rules.rulebase

+ + + + + + + 
 1from pydantic import AliasPath, ConfigDict, Field
+ 2
+ 3from pa_api.xmlapi.types.utils import List, XMLBaseModel
+ 4
+ 5from .nat import NAT
+ 6from .security import Security
+ 7
+ 8
+ 9class RuleBase(XMLBaseModel):
+10    model_config = ConfigDict(extra="allow")
+11
+12    security: List[Security] = Field(
+13        validation_alias=AliasPath("security", "rules", "entry"),
+14        default_factory=list,
+15    )
+16    nat: List[NAT] = Field(
+17        validation_alias=AliasPath("nat", "rules", "entry"),
+18        default_factory=list,
+19    )
+
+ + +
+
+ +
+ + class + RuleBase(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
10class RuleBase(XMLBaseModel):
+11    model_config = ConfigDict(extra="allow")
+12
+13    security: List[Security] = Field(
+14        validation_alias=AliasPath("security", "rules", "entry"),
+15        default_factory=list,
+16    )
+17    nat: List[NAT] = Field(
+18        validation_alias=AliasPath("nat", "rules", "entry"),
+19        default_factory=list,
+20    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ security: Annotated[List[pa_api.xmlapi.types.config.rules.security.Security], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ nat: Annotated[List[pa_api.xmlapi.types.config.rules.nat.NAT], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ model_fields = + + {'security': FieldInfo(annotation=List[Security], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['security', 'rules', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'nat': FieldInfo(annotation=List[NAT], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['nat', 'rules', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/rules/security.html b/public/pa_api/xmlapi/types/config/rules/security.html new file mode 100644 index 0000000..384a312 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/rules/security.html @@ -0,0 +1,1323 @@ + + + + + + + pa_api.xmlapi.types.config.rules.security API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.rules.security

+ + + + + + + 
 1from typing import Literal, Optional
+ 2
+ 3from pydantic import AliasPath, ConfigDict, Field
+ 4
+ 5from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+ 6
+ 7
+ 8class ProfileSetting(XMLBaseModel):
+ 9    groups: List[String] = Field(
+10        validation_alias=AliasPath("group", "member"), default_factory=list
+11    )
+12
+13
+14class Option(XMLBaseModel):
+15    disable_server_response_inspection: Optional[bool] = Field(
+16        validation_alias="disable-server-response-inspection", default=None
+17    )
+18
+19
+20class Target(XMLBaseModel):
+21    negate: Optional[bool] = None
+22
+23
+24class Security(XMLBaseModel):
+25    model_config = ConfigDict(extra="allow")
+26
+27    name: String = Field(validation_alias="@name")
+28    uuid: String = Field(validation_alias="@uuid")
+29    disabled: Optional[bool] = None
+30
+31    action: Literal["allow", "deny", "reset-client"]
+32
+33    to: List[String] = Field(
+34        validation_alias=AliasPath("to", "member"), default_factory=list
+35    )
+36    from_: List[String] = Field(
+37        validation_alias=AliasPath("from", "member"), default_factory=list
+38    )
+39    sources: List[String] = Field(
+40        validation_alias=AliasPath("source", "member"), default_factory=list
+41    )
+42    destinations: List[String] = Field(
+43        validation_alias=AliasPath("destination", "member"), default_factory=list
+44    )
+45    source_users: List[String] = Field(
+46        validation_alias=AliasPath("source-user", "member"), default_factory=list
+47    )
+48    services: List[String] = Field(
+49        validation_alias=AliasPath("service", "member"), default_factory=list
+50    )
+51    applications: List[String] = Field(
+52        validation_alias=AliasPath("application", "member"), default_factory=list
+53    )
+54
+55    description: String = ""
+56    categories: List[String] = Field(
+57        validation_alias=AliasPath("category", "member"), default_factory=list
+58    )
+59    tags: List[String] = Field(
+60        validation_alias=AliasPath("tag", "member"), default_factory=list
+61    )
+62    group_tag: Optional[String] = Field(validation_alias="group-tag", default=None)
+63
+64    profile_settings: List[ProfileSetting] = Field(
+65        validation_alias=AliasPath("profile-settings"), default_factory=list
+66    )
+67    target: Optional[Target] = Field(validation_alias=AliasPath("target"), default=None)
+68
+69    option: Optional[Option] = Field(default=None)
+70    rule_type: Optional[str] = Field(validation_alias="rule-type", default=None)
+71    negate_source: Optional[bool] = Field(
+72        validation_alias="negate-source", default=None
+73    )
+74    negate_destination: Optional[bool] = Field(
+75        validation_alias="negate-destination", default=None
+76    )
+77    log_settings: Optional[str] = Field(validation_alias="log-settings", default=None)
+78    log_start: Optional[bool] = Field(validation_alias="log-start", default=None)
+79    log_end: Optional[bool] = Field(validation_alias="log-end", default=None)
+80    icmp_unreachable: Optional[bool] = Field(
+81        validation_alias="icmp-unreachable", default=None
+82    )
+
+ + +
+
+ +
+ + class + ProfileSetting(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 9class ProfileSetting(XMLBaseModel):
+10    groups: List[String] = Field(
+11        validation_alias=AliasPath("group", "member"), default_factory=list
+12    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ groups: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'groups': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['group', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Option(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
15class Option(XMLBaseModel):
+16    disable_server_response_inspection: Optional[bool] = Field(
+17        validation_alias="disable-server-response-inspection", default=None
+18    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ disable_server_response_inspection: Optional[bool] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'disable_server_response_inspection': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='disable-server-response-inspection')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Target(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
21class Target(XMLBaseModel):
+22    negate: Optional[bool] = None
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ negate: Optional[bool] + + +
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = +{'negate': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Security(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
25class Security(XMLBaseModel):
+26    model_config = ConfigDict(extra="allow")
+27
+28    name: String = Field(validation_alias="@name")
+29    uuid: String = Field(validation_alias="@uuid")
+30    disabled: Optional[bool] = None
+31
+32    action: Literal["allow", "deny", "reset-client"]
+33
+34    to: List[String] = Field(
+35        validation_alias=AliasPath("to", "member"), default_factory=list
+36    )
+37    from_: List[String] = Field(
+38        validation_alias=AliasPath("from", "member"), default_factory=list
+39    )
+40    sources: List[String] = Field(
+41        validation_alias=AliasPath("source", "member"), default_factory=list
+42    )
+43    destinations: List[String] = Field(
+44        validation_alias=AliasPath("destination", "member"), default_factory=list
+45    )
+46    source_users: List[String] = Field(
+47        validation_alias=AliasPath("source-user", "member"), default_factory=list
+48    )
+49    services: List[String] = Field(
+50        validation_alias=AliasPath("service", "member"), default_factory=list
+51    )
+52    applications: List[String] = Field(
+53        validation_alias=AliasPath("application", "member"), default_factory=list
+54    )
+55
+56    description: String = ""
+57    categories: List[String] = Field(
+58        validation_alias=AliasPath("category", "member"), default_factory=list
+59    )
+60    tags: List[String] = Field(
+61        validation_alias=AliasPath("tag", "member"), default_factory=list
+62    )
+63    group_tag: Optional[String] = Field(validation_alias="group-tag", default=None)
+64
+65    profile_settings: List[ProfileSetting] = Field(
+66        validation_alias=AliasPath("profile-settings"), default_factory=list
+67    )
+68    target: Optional[Target] = Field(validation_alias=AliasPath("target"), default=None)
+69
+70    option: Optional[Option] = Field(default=None)
+71    rule_type: Optional[str] = Field(validation_alias="rule-type", default=None)
+72    negate_source: Optional[bool] = Field(
+73        validation_alias="negate-source", default=None
+74    )
+75    negate_destination: Optional[bool] = Field(
+76        validation_alias="negate-destination", default=None
+77    )
+78    log_settings: Optional[str] = Field(validation_alias="log-settings", default=None)
+79    log_start: Optional[bool] = Field(validation_alias="log-start", default=None)
+80    log_end: Optional[bool] = Field(validation_alias="log-end", default=None)
+81    icmp_unreachable: Optional[bool] = Field(
+82        validation_alias="icmp-unreachable", default=None
+83    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ uuid: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ disabled: Optional[bool] + + +
+ + + + +
+
+
+ action: Literal['allow', 'deny', 'reset-client'] + + +
+ + + + +
+
+
+ to: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ from_: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ sources: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ destinations: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ source_users: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ services: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ applications: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ description: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ categories: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ tags: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ group_tag: Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]] + + +
+ + + + +
+
+
+ profile_settings: Annotated[List[ProfileSetting], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ target: Optional[Target] + + +
+ + + + +
+
+
+ option: Optional[Option] + + +
+ + + + +
+
+
+ rule_type: Optional[str] + + +
+ + + + +
+
+
+ negate_source: Optional[bool] + + +
+ + + + +
+
+
+ negate_destination: Optional[bool] + + +
+ + + + +
+
+
+ log_settings: Optional[str] + + +
+ + + + +
+
+
+ log_start: Optional[bool] + + +
+ + + + +
+
+
+ log_end: Optional[bool] + + +
+ + + + +
+
+
+ icmp_unreachable: Optional[bool] + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@uuid', metadata=[BeforeValidator(func=<function ensure_str>)]), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'action': FieldInfo(annotation=Literal['allow', 'deny', 'reset-client'], required=True), 'to': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['to', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'from_': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['from', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'sources': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['source', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'destinations': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['destination', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'source_users': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['source-user', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'services': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['service', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'applications': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['application', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'categories': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['category', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'group_tag': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='group-tag'), 'profile_settings': FieldInfo(annotation=List[ProfileSetting], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['profile-settings']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'target': FieldInfo(annotation=Union[Target, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['target'])), 'option': FieldInfo(annotation=Union[Option, NoneType], required=False, default=None), 'rule_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='rule-type'), 'negate_source': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='negate-source'), 'negate_destination': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='negate-destination'), 'log_settings': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-settings'), 'log_start': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-start'), 'log_end': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-end'), 'icmp_unreachable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='icmp-unreachable')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/config/zone.html b/public/pa_api/xmlapi/types/config/zone.html new file mode 100644 index 0000000..c818e43 --- /dev/null +++ b/public/pa_api/xmlapi/types/config/zone.html @@ -0,0 +1,666 @@ + + + + + + + pa_api.xmlapi.types.config.zone API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.config.zone

+ + + + + + + 
 1from typing import Optional
+ 2
+ 3from pydantic import AliasPath, ConfigDict, Field
+ 4
+ 5from pa_api.xmlapi.types.utils import List, String, XMLBaseModel
+ 6
+ 7
+ 8class ZoneNetwork(XMLBaseModel):
+ 9    model_config = ConfigDict(extra="allow")
+10
+11    name: String = Field(validation_alias="@name", default="")
+12    layer3: List[String] = Field(
+13        validation_alias=AliasPath("layer3", "member"),
+14        default_factory=list,
+15    )
+16    enable_packet_buffer_protection: Optional[bool] = Field(
+17        validation_alias=AliasPath("enable-packet-buffer-protection", "#text"),
+18        default=None,
+19    )
+20
+21
+22class Zone(XMLBaseModel):
+23    model_config = ConfigDict(extra="allow")
+24
+25    name: String = Field(validation_alias="@name", default="")
+26    network: Optional[ZoneNetwork] = None
+27    enable_user_identification: Optional[bool] = Field(
+28        validation_alias=AliasPath("enable-user-identification", "#text"), default=None
+29    )
+30    enable_device_identification: Optional[bool] = Field(
+31        validation_alias=AliasPath("enable-device-identification", "#text"),
+32        default=None,
+33    )
+
+ + +
+
+ +
+ + class + ZoneNetwork(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 9class ZoneNetwork(XMLBaseModel):
+10    model_config = ConfigDict(extra="allow")
+11
+12    name: String = Field(validation_alias="@name", default="")
+13    layer3: List[String] = Field(
+14        validation_alias=AliasPath("layer3", "member"),
+15        default_factory=list,
+16    )
+17    enable_packet_buffer_protection: Optional[bool] = Field(
+18        validation_alias=AliasPath("enable-packet-buffer-protection", "#text"),
+19        default=None,
+20    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ layer3: Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)] + + +
+ + + + +
+
+
+ enable_packet_buffer_protection: Optional[bool] + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'layer3': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'enable_packet_buffer_protection': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-packet-buffer-protection', '#text']))} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + Zone(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
23class Zone(XMLBaseModel):
+24    model_config = ConfigDict(extra="allow")
+25
+26    name: String = Field(validation_alias="@name", default="")
+27    network: Optional[ZoneNetwork] = None
+28    enable_user_identification: Optional[bool] = Field(
+29        validation_alias=AliasPath("enable-user-identification", "#text"), default=None
+30    )
+31    enable_device_identification: Optional[bool] = Field(
+32        validation_alias=AliasPath("enable-device-identification", "#text"),
+33        default=None,
+34    )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ name: typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)] + + +
+ + + + +
+
+
+ network: Optional[ZoneNetwork] + + +
+ + + + +
+
+
+ enable_user_identification: Optional[bool] + + +
+ + + + +
+
+
+ enable_device_identification: Optional[bool] + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'network': FieldInfo(annotation=Union[ZoneNetwork, NoneType], required=False, default=None), 'enable_user_identification': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-user-identification', '#text'])), 'enable_device_identification': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-device-identification', '#text']))} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/operations.html b/public/pa_api/xmlapi/types/operations.html new file mode 100644 index 0000000..9a76b24 --- /dev/null +++ b/public/pa_api/xmlapi/types/operations.html @@ -0,0 +1,247 @@ + + + + + + + pa_api.xmlapi.types.operations API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.operations

+ + + + + + + 
1from . import device, job, software
+2from .device import Device, HAInfo, VPNFlow
+3from .job import Job, JobResult
+4from .software import SoftwareVersion
+
+ + +
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/operations/device.html b/public/pa_api/xmlapi/types/operations/device.html new file mode 100644 index 0000000..4e23f02 --- /dev/null +++ b/public/pa_api/xmlapi/types/operations/device.html @@ -0,0 +1,1976 @@ + + + + + + + pa_api.xmlapi.types.operations.device API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.operations.device

+ + + + + + + 
  1from typing import Optional
+  2
+  3from pydantic import AliasPath, ConfigDict, Field
+  4
+  5from pa_api.utils import (
+  6    first,
+  7)
+  8from pa_api.xmlapi.types.utils import (
+  9    Datetime,
+ 10    XMLBaseModel,
+ 11    mksx,
+ 12)
+ 13
+ 14
+ 15class Device(XMLBaseModel):
+ 16    model_config = ConfigDict(populate_by_name=True, extra="allow")
+ 17
+ 18    serial: str
+ 19    connected: bool
+ 20    unsupported_version: bool = Field(validation_alias="unsupported-version")
+ 21    wildfire_rt: bool = Field(validation_alias="wildfire-rt")
+ 22    deactivated: Optional[str] = None
+ 23    hostname: Optional[str] = None
+ 24    ip_address: Optional[str] = Field(validation_alias="ip-address", default=None)
+ 25    ipv6_address: Optional[str] = Field(validation_alias="ipv6-address", default=None)
+ 26    mac_addr: Optional[str] = Field(validation_alias="mac-addr", default=None)
+ 27    uptime: Optional[str] = None
+ 28    family: Optional[str] = None
+ 29    model: Optional[str] = None
+ 30    sw_version: Optional[str] = Field(validation_alias="sw-version", default=None)
+ 31    app_version: Optional[str] = Field(validation_alias="app-version", default=None)
+ 32    av_version: Optional[str] = Field(validation_alias="av-version", default=None)
+ 33    device_dictionary_version: Optional[str] = Field(
+ 34        validation_alias="device-dictionary-version", default=""
+ 35    )
+ 36    wildfire_version: Optional[str] = Field(
+ 37        validation_alias="wildfire-version", default=None
+ 38    )
+ 39    threat_version: Optional[str] = Field(
+ 40        validation_alias="threat-version", default=None
+ 41    )
+ 42    url_db: Optional[str] = Field(validation_alias="url-db", default=None)
+ 43    url_filtering_version: Optional[str] = Field(
+ 44        validation_alias="url-filtering-version", default=None
+ 45    )
+ 46    logdb_version: Optional[str] = Field(validation_alias="logdb-version", default=None)
+ 47    vpnclient_package_version: Optional[str] = Field(
+ 48        validation_alias="vpnclient-package-version", default=None
+ 49    )
+ 50    global_protect_client_package_version: Optional[str] = Field(
+ 51        validation_alias="global-protect-client-package-version", default=None
+ 52    )
+ 53    prev_app_version: Optional[str] = Field(
+ 54        validation_alias="prev-app-version", default=None
+ 55    )
+ 56    prev_av_version: Optional[str] = Field(
+ 57        validation_alias="prev-av-version", default=None
+ 58    )
+ 59    prev_threat_version: Optional[str] = Field(
+ 60        validation_alias="prev-threat-version", default=None
+ 61    )
+ 62    prev_wildfire_version: Optional[str] = Field(
+ 63        validation_alias="prev-wildfire-version", default=None
+ 64    )
+ 65    prev_device_dictionary_version: Optional[str] = Field(
+ 66        validation_alias="prev-device-dictionary-version", default=""
+ 67    )
+ 68    # domain/: str
+ 69    # slot_count: str
+ 70    # type/: str
+ 71    # tag/: str
+ 72    # plugin_versions
+ 73    # ha_cluster
+ 74    ha_peer_serial: Optional[str] = Field(
+ 75        validation_alias=AliasPath("ha", "peer", "serial", "#text"), default=None
+ 76    )
+ 77    vpn_disable_mode: bool = Field(validation_alias="vpn-disable-mode")
+ 78    operational_mode: str = Field(validation_alias="operational-mode")
+ 79    certificate_status: Optional[str] = Field(
+ 80        validation_alias="certificate-status", default=None
+ 81    )
+ 82    certificate_subject_name: Optional[str] = Field(
+ 83        validation_alias="certificate-subject-name", default=None
+ 84    )
+ 85    certificate_expiry: Optional[Datetime] = Field(
+ 86        validation_alias="certificate-expiry", default=None
+ 87    )
+ 88    connected_at: Optional[Datetime] = Field(
+ 89        validation_alias="connected-at", default=None
+ 90    )
+ 91    custom_certificate_usage: Optional[str] = Field(
+ 92        validation_alias="custom-certificate-usage", default=None
+ 93    )
+ 94    multi_vsys: bool = Field(validation_alias="multi-vsys")
+ 95    # vsys
+ 96    last_masterkey_push_status: str = Field(
+ 97        validation_alias="last-masterkey-push-status"
+ 98    )
+ 99    last_masterkey_push_timestamp: Optional[str] = Field(
+100        validation_alias="last-masterkey-push-timestamp", default=None
+101    )
+102    express_mode: bool = Field(validation_alias="express-mode")
+103    device_cert_present: Optional[str] = Field(
+104        validation_alias="device-cert-present", default=None
+105    )
+106    device_cert_expiry_date: str = Field(validation_alias="device-cert-expiry-date")
+107
+108
+109class VPNFlow(XMLBaseModel):
+110    model_config = ConfigDict(populate_by_name=True, extra="allow")
+111
+112    name: str
+113    id: int
+114    gwid: int
+115    inner_if: str = Field(validation_alias="inner-if")
+116    outer_if: str = Field(validation_alias="outer-if")
+117    localip: str
+118    peerip: str
+119    state: str
+120    mon: str
+121    owner: str
+122
+123
+124class HAInfo(XMLBaseModel):
+125    model_config = ConfigDict(populate_by_name=True, extra="allow")
+126
+127    enabled: bool
+128    preemptive: Optional[bool] = None
+129    mode: Optional[str] = None
+130    state: Optional[str] = None
+131    peer_state: Optional[str] = None
+132    priority: Optional[int] = None
+133    peer_priority: Optional[int] = None
+134    is_primary: Optional[bool] = None
+135    peer_conn_status: Optional[str] = None
+136    mgmt_ip: Optional[str] = None
+137    ha1_ipaddr: Optional[str] = None
+138    ha1_backup_ipaddr: Optional[str] = None
+139    ha2_ipaddr: Optional[str] = None
+140    ha1_macaddress: Optional[str] = None
+141    ha1_backup_macaddress: Optional[str] = None
+142    ha2_macaddress: Optional[str] = None
+143
+144    @classmethod
+145    def from_xml(cls, xml):
+146        # TODO: Use correct pydantic functionalities
+147        if isinstance(xml, (list, tuple)):
+148            xml = first(xml)
+149        if xml is None:
+150            return None
+151        p = mksx(xml)
+152        priority = p("./group/local-info/priority/text()", parser=int)
+153        peer_priority = p("./group/peer-info/priority/text()", parser=int)
+154        is_primary = None
+155        if priority is not None and peer_priority is not None:
+156            is_primary = priority < peer_priority
+157        return HAInfo(
+158            enabled=p("./enabled/text()"),
+159            preemptive=p("./group/local-info/preemptive/text()"),
+160            mode=p("./group/local-info/mode/text()"),
+161            state=p("./group/local-info/state/text()"),
+162            peer_state=p("./group/peer-info/state/text()"),
+163            priority=priority,
+164            peer_priority=peer_priority,
+165            is_primary=is_primary,
+166            peer_conn_status=p("./group/peer-info/conn-status/text()"),
+167            mgmt_ip=p("./group/local-info/mgmt-ip/text()"),
+168            ha1_ipaddr=p("./group/local-info/ha1-ipaddr/text()"),
+169            ha1_backup_ipaddr=p("./group/local-info/ha1-backup-ipaddr/text()"),
+170            ha2_ipaddr=p("./group/local-info/ha2-ipaddr/text()"),
+171            ha1_macaddress=p("./group/local-info/ha1-macaddr/text()"),
+172            ha1_backup_macaddress=p("./group/local-info/ha1-backup-macaddr/text()"),
+173            ha2_macaddress=p("./group/local-info/ha2-macaddr/text()"),
+174        )
+
+ + +
+
+ +
+ + class + Device(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
 16class Device(XMLBaseModel):
+ 17    model_config = ConfigDict(populate_by_name=True, extra="allow")
+ 18
+ 19    serial: str
+ 20    connected: bool
+ 21    unsupported_version: bool = Field(validation_alias="unsupported-version")
+ 22    wildfire_rt: bool = Field(validation_alias="wildfire-rt")
+ 23    deactivated: Optional[str] = None
+ 24    hostname: Optional[str] = None
+ 25    ip_address: Optional[str] = Field(validation_alias="ip-address", default=None)
+ 26    ipv6_address: Optional[str] = Field(validation_alias="ipv6-address", default=None)
+ 27    mac_addr: Optional[str] = Field(validation_alias="mac-addr", default=None)
+ 28    uptime: Optional[str] = None
+ 29    family: Optional[str] = None
+ 30    model: Optional[str] = None
+ 31    sw_version: Optional[str] = Field(validation_alias="sw-version", default=None)
+ 32    app_version: Optional[str] = Field(validation_alias="app-version", default=None)
+ 33    av_version: Optional[str] = Field(validation_alias="av-version", default=None)
+ 34    device_dictionary_version: Optional[str] = Field(
+ 35        validation_alias="device-dictionary-version", default=""
+ 36    )
+ 37    wildfire_version: Optional[str] = Field(
+ 38        validation_alias="wildfire-version", default=None
+ 39    )
+ 40    threat_version: Optional[str] = Field(
+ 41        validation_alias="threat-version", default=None
+ 42    )
+ 43    url_db: Optional[str] = Field(validation_alias="url-db", default=None)
+ 44    url_filtering_version: Optional[str] = Field(
+ 45        validation_alias="url-filtering-version", default=None
+ 46    )
+ 47    logdb_version: Optional[str] = Field(validation_alias="logdb-version", default=None)
+ 48    vpnclient_package_version: Optional[str] = Field(
+ 49        validation_alias="vpnclient-package-version", default=None
+ 50    )
+ 51    global_protect_client_package_version: Optional[str] = Field(
+ 52        validation_alias="global-protect-client-package-version", default=None
+ 53    )
+ 54    prev_app_version: Optional[str] = Field(
+ 55        validation_alias="prev-app-version", default=None
+ 56    )
+ 57    prev_av_version: Optional[str] = Field(
+ 58        validation_alias="prev-av-version", default=None
+ 59    )
+ 60    prev_threat_version: Optional[str] = Field(
+ 61        validation_alias="prev-threat-version", default=None
+ 62    )
+ 63    prev_wildfire_version: Optional[str] = Field(
+ 64        validation_alias="prev-wildfire-version", default=None
+ 65    )
+ 66    prev_device_dictionary_version: Optional[str] = Field(
+ 67        validation_alias="prev-device-dictionary-version", default=""
+ 68    )
+ 69    # domain/: str
+ 70    # slot_count: str
+ 71    # type/: str
+ 72    # tag/: str
+ 73    # plugin_versions
+ 74    # ha_cluster
+ 75    ha_peer_serial: Optional[str] = Field(
+ 76        validation_alias=AliasPath("ha", "peer", "serial", "#text"), default=None
+ 77    )
+ 78    vpn_disable_mode: bool = Field(validation_alias="vpn-disable-mode")
+ 79    operational_mode: str = Field(validation_alias="operational-mode")
+ 80    certificate_status: Optional[str] = Field(
+ 81        validation_alias="certificate-status", default=None
+ 82    )
+ 83    certificate_subject_name: Optional[str] = Field(
+ 84        validation_alias="certificate-subject-name", default=None
+ 85    )
+ 86    certificate_expiry: Optional[Datetime] = Field(
+ 87        validation_alias="certificate-expiry", default=None
+ 88    )
+ 89    connected_at: Optional[Datetime] = Field(
+ 90        validation_alias="connected-at", default=None
+ 91    )
+ 92    custom_certificate_usage: Optional[str] = Field(
+ 93        validation_alias="custom-certificate-usage", default=None
+ 94    )
+ 95    multi_vsys: bool = Field(validation_alias="multi-vsys")
+ 96    # vsys
+ 97    last_masterkey_push_status: str = Field(
+ 98        validation_alias="last-masterkey-push-status"
+ 99    )
+100    last_masterkey_push_timestamp: Optional[str] = Field(
+101        validation_alias="last-masterkey-push-timestamp", default=None
+102    )
+103    express_mode: bool = Field(validation_alias="express-mode")
+104    device_cert_present: Optional[str] = Field(
+105        validation_alias="device-cert-present", default=None
+106    )
+107    device_cert_expiry_date: str = Field(validation_alias="device-cert-expiry-date")
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'populate_by_name': True, 'extra': 'allow'} + + +
+ + + + +
+
+
+ serial: str + + +
+ + + + +
+
+
+ connected: bool + + +
+ + + + +
+
+
+ unsupported_version: bool + + +
+ + + + +
+
+
+ wildfire_rt: bool + + +
+ + + + +
+
+
+ deactivated: Optional[str] + + +
+ + + + +
+
+
+ hostname: Optional[str] + + +
+ + + + +
+
+
+ ip_address: Optional[str] + + +
+ + + + +
+
+
+ ipv6_address: Optional[str] + + +
+ + + + +
+
+
+ mac_addr: Optional[str] + + +
+ + + + +
+
+
+ uptime: Optional[str] + + +
+ + + + +
+
+
+ family: Optional[str] + + +
+ + + + +
+
+
+ model: Optional[str] + + +
+ + + + +
+
+
+ sw_version: Optional[str] + + +
+ + + + +
+
+
+ app_version: Optional[str] + + +
+ + + + +
+
+
+ av_version: Optional[str] + + +
+ + + + +
+
+
+ device_dictionary_version: Optional[str] + + +
+ + + + +
+
+
+ wildfire_version: Optional[str] + + +
+ + + + +
+
+
+ threat_version: Optional[str] + + +
+ + + + +
+
+
+ url_db: Optional[str] + + +
+ + + + +
+
+
+ url_filtering_version: Optional[str] + + +
+ + + + +
+
+
+ logdb_version: Optional[str] + + +
+ + + + +
+
+
+ vpnclient_package_version: Optional[str] + + +
+ + + + +
+
+
+ global_protect_client_package_version: Optional[str] + + +
+ + + + +
+
+
+ prev_app_version: Optional[str] + + +
+ + + + +
+
+
+ prev_av_version: Optional[str] + + +
+ + + + +
+
+
+ prev_threat_version: Optional[str] + + +
+ + + + +
+
+
+ prev_wildfire_version: Optional[str] + + +
+ + + + +
+
+
+ prev_device_dictionary_version: Optional[str] + + +
+ + + + +
+
+
+ ha_peer_serial: Optional[str] + + +
+ + + + +
+
+
+ vpn_disable_mode: bool + + +
+ + + + +
+
+
+ operational_mode: str + + +
+ + + + +
+
+
+ certificate_status: Optional[str] + + +
+ + + + +
+
+
+ certificate_subject_name: Optional[str] + + +
+ + + + +
+
+
+ certificate_expiry: Optional[Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime at 0x7ef48ae62200>)]] + + +
+ + + + +
+
+
+ connected_at: Optional[Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime at 0x7ef48ae62200>)]] + + +
+ + + + +
+
+
+ custom_certificate_usage: Optional[str] + + +
+ + + + +
+
+
+ multi_vsys: bool + + +
+ + + + +
+
+
+ last_masterkey_push_status: str + + +
+ + + + +
+
+
+ last_masterkey_push_timestamp: Optional[str] + + +
+ + + + +
+
+
+ express_mode: bool + + +
+ + + + +
+
+
+ device_cert_present: Optional[str] + + +
+ + + + +
+
+
+ device_cert_expiry_date: str + + +
+ + + + +
+
+
+ model_fields = + + {'serial': FieldInfo(annotation=str, required=True), 'connected': FieldInfo(annotation=bool, required=True), 'unsupported_version': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='unsupported-version'), 'wildfire_rt': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='wildfire-rt'), 'deactivated': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'hostname': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ip_address': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='ip-address'), 'ipv6_address': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='ipv6-address'), 'mac_addr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='mac-addr'), 'uptime': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'family': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'model': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'sw_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='sw-version'), 'app_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='app-version'), 'av_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='av-version'), 'device_dictionary_version': FieldInfo(annotation=Union[str, NoneType], required=False, default='', alias_priority=2, validation_alias='device-dictionary-version'), 'wildfire_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='wildfire-version'), 'threat_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='threat-version'), 'url_db': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='url-db'), 'url_filtering_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='url-filtering-version'), 'logdb_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='logdb-version'), 'vpnclient_package_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='vpnclient-package-version'), 'global_protect_client_package_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='global-protect-client-package-version'), 'prev_app_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-app-version'), 'prev_av_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-av-version'), 'prev_threat_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-threat-version'), 'prev_wildfire_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-wildfire-version'), 'prev_device_dictionary_version': FieldInfo(annotation=Union[str, NoneType], required=False, default='', alias_priority=2, validation_alias='prev-device-dictionary-version'), 'ha_peer_serial': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['ha', 'peer', 'serial', '#text'])), 'vpn_disable_mode': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='vpn-disable-mode'), 'operational_mode': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='operational-mode'), 'certificate_status': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-status'), 'certificate_subject_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-subject-name'), 'certificate_expiry': FieldInfo(annotation=Union[Annotated[datetime, PlainValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-expiry'), 'connected_at': FieldInfo(annotation=Union[Annotated[datetime, PlainValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='connected-at'), 'custom_certificate_usage': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='custom-certificate-usage'), 'multi_vsys': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='multi-vsys'), 'last_masterkey_push_status': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='last-masterkey-push-status'), 'last_masterkey_push_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='last-masterkey-push-timestamp'), 'express_mode': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='express-mode'), 'device_cert_present': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='device-cert-present'), 'device_cert_expiry_date': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='device-cert-expiry-date')} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + VPNFlow(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
110class VPNFlow(XMLBaseModel):
+111    model_config = ConfigDict(populate_by_name=True, extra="allow")
+112
+113    name: str
+114    id: int
+115    gwid: int
+116    inner_if: str = Field(validation_alias="inner-if")
+117    outer_if: str = Field(validation_alias="outer-if")
+118    localip: str
+119    peerip: str
+120    state: str
+121    mon: str
+122    owner: str
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'populate_by_name': True, 'extra': 'allow'} + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ id: int + + +
+ + + + +
+
+
+ gwid: int + + +
+ + + + +
+
+
+ inner_if: str + + +
+ + + + +
+
+
+ outer_if: str + + +
+ + + + +
+
+
+ localip: str + + +
+ + + + +
+
+
+ peerip: str + + +
+ + + + +
+
+
+ state: str + + +
+ + + + +
+
+
+ mon: str + + +
+ + + + +
+
+
+ owner: str + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'gwid': FieldInfo(annotation=int, required=True), 'inner_if': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='inner-if'), 'outer_if': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='outer-if'), 'localip': FieldInfo(annotation=str, required=True), 'peerip': FieldInfo(annotation=str, required=True), 'state': FieldInfo(annotation=str, required=True), 'mon': FieldInfo(annotation=str, required=True), 'owner': FieldInfo(annotation=str, required=True)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+ +
+
+
+
+ +
+ + class + HAInfo(pa_api.xmlapi.types.utils.XMLBaseModel): + + + +
+ + 
125class HAInfo(XMLBaseModel):
+126    model_config = ConfigDict(populate_by_name=True, extra="allow")
+127
+128    enabled: bool
+129    preemptive: Optional[bool] = None
+130    mode: Optional[str] = None
+131    state: Optional[str] = None
+132    peer_state: Optional[str] = None
+133    priority: Optional[int] = None
+134    peer_priority: Optional[int] = None
+135    is_primary: Optional[bool] = None
+136    peer_conn_status: Optional[str] = None
+137    mgmt_ip: Optional[str] = None
+138    ha1_ipaddr: Optional[str] = None
+139    ha1_backup_ipaddr: Optional[str] = None
+140    ha2_ipaddr: Optional[str] = None
+141    ha1_macaddress: Optional[str] = None
+142    ha1_backup_macaddress: Optional[str] = None
+143    ha2_macaddress: Optional[str] = None
+144
+145    @classmethod
+146    def from_xml(cls, xml):
+147        # TODO: Use correct pydantic functionalities
+148        if isinstance(xml, (list, tuple)):
+149            xml = first(xml)
+150        if xml is None:
+151            return None
+152        p = mksx(xml)
+153        priority = p("./group/local-info/priority/text()", parser=int)
+154        peer_priority = p("./group/peer-info/priority/text()", parser=int)
+155        is_primary = None
+156        if priority is not None and peer_priority is not None:
+157            is_primary = priority < peer_priority
+158        return HAInfo(
+159            enabled=p("./enabled/text()"),
+160            preemptive=p("./group/local-info/preemptive/text()"),
+161            mode=p("./group/local-info/mode/text()"),
+162            state=p("./group/local-info/state/text()"),
+163            peer_state=p("./group/peer-info/state/text()"),
+164            priority=priority,
+165            peer_priority=peer_priority,
+166            is_primary=is_primary,
+167            peer_conn_status=p("./group/peer-info/conn-status/text()"),
+168            mgmt_ip=p("./group/local-info/mgmt-ip/text()"),
+169            ha1_ipaddr=p("./group/local-info/ha1-ipaddr/text()"),
+170            ha1_backup_ipaddr=p("./group/local-info/ha1-backup-ipaddr/text()"),
+171            ha2_ipaddr=p("./group/local-info/ha2-ipaddr/text()"),
+172            ha1_macaddress=p("./group/local-info/ha1-macaddr/text()"),
+173            ha1_backup_macaddress=p("./group/local-info/ha1-backup-macaddr/text()"),
+174            ha2_macaddress=p("./group/local-info/ha2-macaddr/text()"),
+175        )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'populate_by_name': True, 'extra': 'allow'} + + +
+ + + + +
+
+
+ enabled: bool + + +
+ + + + +
+
+
+ preemptive: Optional[bool] + + +
+ + + + +
+
+
+ mode: Optional[str] + + +
+ + + + +
+
+
+ state: Optional[str] + + +
+ + + + +
+
+
+ peer_state: Optional[str] + + +
+ + + + +
+
+
+ priority: Optional[int] + + +
+ + + + +
+
+
+ peer_priority: Optional[int] + + +
+ + + + +
+
+
+ is_primary: Optional[bool] + + +
+ + + + +
+
+
+ peer_conn_status: Optional[str] + + +
+ + + + +
+
+
+ mgmt_ip: Optional[str] + + +
+ + + + +
+
+
+ ha1_ipaddr: Optional[str] + + +
+ + + + +
+
+
+ ha1_backup_ipaddr: Optional[str] + + +
+ + + + +
+
+
+ ha2_ipaddr: Optional[str] + + +
+ + + + +
+
+
+ ha1_macaddress: Optional[str] + + +
+ + + + +
+
+
+ ha1_backup_macaddress: Optional[str] + + +
+ + + + +
+
+
+ ha2_macaddress: Optional[str] + + +
+ + + + +
+
+ +
+
@classmethod
+ + def + from_xml(cls, xml): + + + +
+ + 
145    @classmethod
+146    def from_xml(cls, xml):
+147        # TODO: Use correct pydantic functionalities
+148        if isinstance(xml, (list, tuple)):
+149            xml = first(xml)
+150        if xml is None:
+151            return None
+152        p = mksx(xml)
+153        priority = p("./group/local-info/priority/text()", parser=int)
+154        peer_priority = p("./group/peer-info/priority/text()", parser=int)
+155        is_primary = None
+156        if priority is not None and peer_priority is not None:
+157            is_primary = priority < peer_priority
+158        return HAInfo(
+159            enabled=p("./enabled/text()"),
+160            preemptive=p("./group/local-info/preemptive/text()"),
+161            mode=p("./group/local-info/mode/text()"),
+162            state=p("./group/local-info/state/text()"),
+163            peer_state=p("./group/peer-info/state/text()"),
+164            priority=priority,
+165            peer_priority=peer_priority,
+166            is_primary=is_primary,
+167            peer_conn_status=p("./group/peer-info/conn-status/text()"),
+168            mgmt_ip=p("./group/local-info/mgmt-ip/text()"),
+169            ha1_ipaddr=p("./group/local-info/ha1-ipaddr/text()"),
+170            ha1_backup_ipaddr=p("./group/local-info/ha1-backup-ipaddr/text()"),
+171            ha2_ipaddr=p("./group/local-info/ha2-ipaddr/text()"),
+172            ha1_macaddress=p("./group/local-info/ha1-macaddr/text()"),
+173            ha1_backup_macaddress=p("./group/local-info/ha1-backup-macaddr/text()"),
+174            ha2_macaddress=p("./group/local-info/ha2-macaddr/text()"),
+175        )
+
+ + + + +
+
+
+ model_fields = + + {'enabled': FieldInfo(annotation=bool, required=True), 'preemptive': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'peer_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'priority': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'peer_priority': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'is_primary': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'peer_conn_status': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'mgmt_ip': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_backup_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha2_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_backup_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha2_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/operations/job.html b/public/pa_api/xmlapi/types/operations/job.html new file mode 100644 index 0000000..5eb4b71 --- /dev/null +++ b/public/pa_api/xmlapi/types/operations/job.html @@ -0,0 +1,794 @@ + + + + + + + pa_api.xmlapi.types.operations.job API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.operations.job

+ + + + + + + 
 1import enum
+ 2import logging
+ 3from dataclasses import dataclass
+ 4from datetime import datetime, time
+ 5from typing import Optional
+ 6
+ 7from pa_api.utils import (
+ 8    first,
+ 9)
+10from pa_api.xmlapi.types.utils import (
+11    mksx,
+12    parse_datetime,
+13    parse_time,
+14    pd,
+15)
+16
+17
+18def parse_tdeq(d):
+19    if "null" in d:
+20        return None
+21    try:
+22        return parse_time(d)
+23    except Exception as e:
+24        logging.debug(e)
+25    return parse_datetime(d)
+26
+27
+28def parse_progress(progress):
+29    try:
+30        return float(progress)
+31    except Exception as e:
+32        logging.debug(f"{e} => Fallback to datetime parsing")
+33
+34    # When finished, progress becomes the date of the end
+35    if parse_datetime(progress):
+36        return 100.0
+37    return None
+38
+39
+40class JobResult(enum.Enum):
+41    OK = "OK"
+42    FAIL = "FAIL"
+43
+44
+45@dataclass
+46class Job:
+47    # TODO: Use pydantic
+48    tenq: datetime
+49    tdeq: time
+50    id: str
+51    user: str
+52    type: str
+53    status: str
+54    queued: bool
+55    stoppable: bool
+56    result: str
+57    tfin: datetime
+58    description: str
+59    position_in_queue: int
+60    progress: float
+61    details: str
+62    warnings: str
+63
+64    @staticmethod
+65    def from_xml(xml) -> Optional["Job"]:
+66        # TODO: Use correct pydantic functionalities
+67        if isinstance(xml, (list, tuple)):
+68            xml = first(xml)
+69        if xml is None:
+70            return None
+71        p = mksx(xml)
+72        return Job(
+73            p("./tenq/text()", parser=pd),
+74            p("./tdeq/text()", parser=parse_tdeq),
+75            p("./id/text()"),
+76            p("./user/text()"),
+77            p("./type/text()"),
+78            p("./status/text()"),
+79            p("./queued/text()") != "NO",
+80            p("./stoppable/text()") != "NO",
+81            p("./result/text()"),
+82            p("./tfin/text()", parser=pd),
+83            p("./description/text()"),
+84            p("./positionInQ/text()", parser=int),
+85            p("./progress/text()", parser=parse_progress),
+86            "\n".join(xml.xpath("./details/line/text()")),
+87            p("./warnings/text()"),
+88        )
+
+ + +
+
+ +
+ + def + parse_tdeq(d): + + + +
+ + 
19def parse_tdeq(d):
+20    if "null" in d:
+21        return None
+22    try:
+23        return parse_time(d)
+24    except Exception as e:
+25        logging.debug(e)
+26    return parse_datetime(d)
+
+ + + + +
+
+ +
+ + def + parse_progress(progress): + + + +
+ + 
29def parse_progress(progress):
+30    try:
+31        return float(progress)
+32    except Exception as e:
+33        logging.debug(f"{e} => Fallback to datetime parsing")
+34
+35    # When finished, progress becomes the date of the end
+36    if parse_datetime(progress):
+37        return 100.0
+38    return None
+
+ + + + +
+
+ +
+ + class + JobResult(enum.Enum): + + + +
+ + 
41class JobResult(enum.Enum):
+42    OK = "OK"
+43    FAIL = "FAIL"
+
+ + +

An enumeration.

+
+ + +
+
+ OK = +<JobResult.OK: 'OK'> + + +
+ + + + +
+
+
+ FAIL = +<JobResult.FAIL: 'FAIL'> + + +
+ + + + +
+
+
Inherited Members
+
+
enum.Enum
+
name
+
value
+ +
+
+
+
+
+ +
+
@dataclass
+ + class + Job: + + + +
+ + 
46@dataclass
+47class Job:
+48    # TODO: Use pydantic
+49    tenq: datetime
+50    tdeq: time
+51    id: str
+52    user: str
+53    type: str
+54    status: str
+55    queued: bool
+56    stoppable: bool
+57    result: str
+58    tfin: datetime
+59    description: str
+60    position_in_queue: int
+61    progress: float
+62    details: str
+63    warnings: str
+64
+65    @staticmethod
+66    def from_xml(xml) -> Optional["Job"]:
+67        # TODO: Use correct pydantic functionalities
+68        if isinstance(xml, (list, tuple)):
+69            xml = first(xml)
+70        if xml is None:
+71            return None
+72        p = mksx(xml)
+73        return Job(
+74            p("./tenq/text()", parser=pd),
+75            p("./tdeq/text()", parser=parse_tdeq),
+76            p("./id/text()"),
+77            p("./user/text()"),
+78            p("./type/text()"),
+79            p("./status/text()"),
+80            p("./queued/text()") != "NO",
+81            p("./stoppable/text()") != "NO",
+82            p("./result/text()"),
+83            p("./tfin/text()", parser=pd),
+84            p("./description/text()"),
+85            p("./positionInQ/text()", parser=int),
+86            p("./progress/text()", parser=parse_progress),
+87            "\n".join(xml.xpath("./details/line/text()")),
+88            p("./warnings/text()"),
+89        )
+
+ + + + +
+
+ + Job( tenq: datetime.datetime, tdeq: datetime.time, id: str, user: str, type: str, status: str, queued: bool, stoppable: bool, result: str, tfin: datetime.datetime, description: str, position_in_queue: int, progress: float, details: str, warnings: str) + + +
+ + + + +
+
+
+ tenq: datetime.datetime + + +
+ + + + +
+
+
+ tdeq: datetime.time + + +
+ + + + +
+
+
+ id: str + + +
+ + + + +
+
+
+ user: str + + +
+ + + + +
+
+
+ type: str + + +
+ + + + +
+
+
+ status: str + + +
+ + + + +
+
+
+ queued: bool + + +
+ + + + +
+
+
+ stoppable: bool + + +
+ + + + +
+
+
+ result: str + + +
+ + + + +
+
+
+ tfin: datetime.datetime + + +
+ + + + +
+
+
+ description: str + + +
+ + + + +
+
+
+ position_in_queue: int + + +
+ + + + +
+
+
+ progress: float + + +
+ + + + +
+
+
+ details: str + + +
+ + + + +
+
+
+ warnings: str + + +
+ + + + +
+
+ +
+
@staticmethod
+ + def + from_xml(xml) -> Optional[Job]: + + + +
+ + 
65    @staticmethod
+66    def from_xml(xml) -> Optional["Job"]:
+67        # TODO: Use correct pydantic functionalities
+68        if isinstance(xml, (list, tuple)):
+69            xml = first(xml)
+70        if xml is None:
+71            return None
+72        p = mksx(xml)
+73        return Job(
+74            p("./tenq/text()", parser=pd),
+75            p("./tdeq/text()", parser=parse_tdeq),
+76            p("./id/text()"),
+77            p("./user/text()"),
+78            p("./type/text()"),
+79            p("./status/text()"),
+80            p("./queued/text()") != "NO",
+81            p("./stoppable/text()") != "NO",
+82            p("./result/text()"),
+83            p("./tfin/text()", parser=pd),
+84            p("./description/text()"),
+85            p("./positionInQ/text()", parser=int),
+86            p("./progress/text()", parser=parse_progress),
+87            "\n".join(xml.xpath("./details/line/text()")),
+88            p("./warnings/text()"),
+89        )
+
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/operations/software.html b/public/pa_api/xmlapi/types/operations/software.html new file mode 100644 index 0000000..2826e21 --- /dev/null +++ b/public/pa_api/xmlapi/types/operations/software.html @@ -0,0 +1,548 @@ + + + + + + + pa_api.xmlapi.types.operations.software API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.operations.software

+ + + + + + + 
 1from dataclasses import dataclass
+ 2from datetime import datetime
+ 3
+ 4from pa_api.utils import (
+ 5    first,
+ 6)
+ 7from pa_api.xmlapi.types.utils import (
+ 8    mksx,
+ 9    pd,
+10)
+11
+12
+13@dataclass
+14class SoftwareVersion:
+15    # TODO: Use pydantic
+16    version: str
+17    filename: str
+18    released_on: datetime
+19    downloaded: bool
+20    current: bool
+21    latest: bool
+22    uploaded: bool
+23
+24    @staticmethod
+25    def from_xml(xml):
+26        # TODO: Use correct pydantic functionalities
+27        if isinstance(xml, (list, tuple)):
+28            xml = first(xml)
+29        if xml is None:
+30            return None
+31        p = mksx(xml)
+32        return SoftwareVersion(
+33            p("./version/text()"),
+34            p("./filename/text()"),
+35            p("./released-on/text()", parser=pd),
+36            p("./downloaded/text()") != "no",
+37            p("./current/text()") != "no",
+38            p("./latest/text()") != "no",
+39            p("./uploaded/text()") != "no",
+40        )
+41
+42    @property
+43    def base_minor_version(self) -> str:
+44        major, minor, _ = self.version.split(".")
+45        return f"{major}.{minor}.0"
+46
+47    @property
+48    def base_major_version(self) -> str:
+49        major, _, _ = self.version.split(".")
+50        return f"{major}.0.0"
+
+ + +
+
+ +
+
@dataclass
+ + class + SoftwareVersion: + + + +
+ + 
14@dataclass
+15class SoftwareVersion:
+16    # TODO: Use pydantic
+17    version: str
+18    filename: str
+19    released_on: datetime
+20    downloaded: bool
+21    current: bool
+22    latest: bool
+23    uploaded: bool
+24
+25    @staticmethod
+26    def from_xml(xml):
+27        # TODO: Use correct pydantic functionalities
+28        if isinstance(xml, (list, tuple)):
+29            xml = first(xml)
+30        if xml is None:
+31            return None
+32        p = mksx(xml)
+33        return SoftwareVersion(
+34            p("./version/text()"),
+35            p("./filename/text()"),
+36            p("./released-on/text()", parser=pd),
+37            p("./downloaded/text()") != "no",
+38            p("./current/text()") != "no",
+39            p("./latest/text()") != "no",
+40            p("./uploaded/text()") != "no",
+41        )
+42
+43    @property
+44    def base_minor_version(self) -> str:
+45        major, minor, _ = self.version.split(".")
+46        return f"{major}.{minor}.0"
+47
+48    @property
+49    def base_major_version(self) -> str:
+50        major, _, _ = self.version.split(".")
+51        return f"{major}.0.0"
+
+ + + + +
+
+ + SoftwareVersion( version: str, filename: str, released_on: datetime.datetime, downloaded: bool, current: bool, latest: bool, uploaded: bool) + + +
+ + + + +
+
+
+ version: str + + +
+ + + + +
+
+
+ filename: str + + +
+ + + + +
+
+
+ released_on: datetime.datetime + + +
+ + + + +
+
+
+ downloaded: bool + + +
+ + + + +
+
+
+ current: bool + + +
+ + + + +
+
+
+ latest: bool + + +
+ + + + +
+
+
+ uploaded: bool + + +
+ + + + +
+
+ +
+
@staticmethod
+ + def + from_xml(xml): + + + +
+ + 
25    @staticmethod
+26    def from_xml(xml):
+27        # TODO: Use correct pydantic functionalities
+28        if isinstance(xml, (list, tuple)):
+29            xml = first(xml)
+30        if xml is None:
+31            return None
+32        p = mksx(xml)
+33        return SoftwareVersion(
+34            p("./version/text()"),
+35            p("./filename/text()"),
+36            p("./released-on/text()", parser=pd),
+37            p("./downloaded/text()") != "no",
+38            p("./current/text()") != "no",
+39            p("./latest/text()") != "no",
+40            p("./uploaded/text()") != "no",
+41        )
+
+ + + + +
+
+ +
+ base_minor_version: str + + + +
+ + 
43    @property
+44    def base_minor_version(self) -> str:
+45        major, minor, _ = self.version.split(".")
+46        return f"{major}.{minor}.0"
+
+ + + + +
+
+ +
+ base_major_version: str + + + +
+ + 
48    @property
+49    def base_major_version(self) -> str:
+50        major, _, _ = self.version.split(".")
+51        return f"{major}.0.0"
+
+ + + + +
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/statistics.html b/public/pa_api/xmlapi/types/statistics.html new file mode 100644 index 0000000..24fdcb5 --- /dev/null +++ b/public/pa_api/xmlapi/types/statistics.html @@ -0,0 +1,1355 @@ + + + + + + + pa_api.xmlapi.types.statistics API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.statistics

+ + + + + + + 
  1from datetime import datetime
+  2from typing import Any, List, Literal, Optional, Union
+  3
+  4from pydantic import AliasChoices, BaseModel, ConfigDict, Field, field_validator
+  5
+  6from pa_api.xmlapi.utils import el2dict as xml2dict
+  7
+  8
+  9class RuleHit(BaseModel):
+ 10    name: str = Field(validation_alias=AliasChoices("@name", "name"))
+ 11    device_group: str = Field(alias="device-group")
+ 12    rulebase: Literal["pre-rulebase", "post-rulebase"] = Field(alias="rulebase")
+ 13    type: str = Field(alias="type")
+ 14    state: Optional[str] = Field(alias="rule-state")
+ 15    modification: datetime = Field(alias="rule-modification-timestamp")
+ 16    creation: datetime = Field(alias="rule-creation-timestamp")
+ 17    all_connected: bool = Field(alias="all-connected")
+ 18
+ 19    @field_validator("modification", "creation", mode="before")
+ 20    @classmethod
+ 21    def ensure_datetime(cls, v: Any):
+ 22        if not isinstance(v, int):
+ 23            v = int(v)
+ 24        return datetime.fromtimestamp(v)
+ 25
+ 26    @staticmethod
+ 27    def from_tuple(t):
+ 28        device_group, rulebase, rule_type, xml = t
+ 29        return RuleHit.model_validate(
+ 30            {
+ 31                "device-group": device_group,
+ 32                "rulebase": rulebase,
+ 33                "type": rule_type,
+ 34                **xml2dict(xml)["entry"],
+ 35            }
+ 36        )
+ 37
+ 38
+ 39class RuleUse(BaseModel):
+ 40    model_config = ConfigDict(extra="allow")
+ 41    name: str = Field(validation_alias=AliasChoices("@name", "name"))
+ 42    description: Optional[str] = Field(default=None)
+ 43    uuid: str = Field(validation_alias=AliasChoices("@uuid", "uuid"))
+ 44    state: Optional[str] = Field(alias="rule-state")
+ 45    bytes: Optional[int] = Field(default=None)
+ 46    group_tag: Optional[str] = Field(alias="group-tag", default=None)
+ 47    tag: Optional[List[str]] = Field(default=None)
+ 48    disabled: Optional[bool] = Field(default=None)
+ 49    rule_type: Optional[Literal["interzone", "universal"]] = Field(
+ 50        alias="rule-type", default=None
+ 51    )
+ 52    nat_type: Optional[Literal["ipv4", "ipv6"]] = Field(alias="nat-type", default=None)
+ 53    modification: datetime = Field(alias="rule-modification-timestamp")
+ 54    creation: datetime = Field(alias="rule-creation-timestamp")
+ 55
+ 56    action: Optional[Union[Literal["allow", "deny", "reset-client"], dict]] = Field(
+ 57        default=None
+ 58    )
+ 59    to_interface: str = Field(alias="to-interface", default=None)
+ 60    protocol: Optional[Literal["tcp", "udp"]] = Field(default=None)
+ 61    port: Optional[str] = Field(default=None)  # Can be a port range
+ 62
+ 63    to_: Optional[List[str]] = Field(alias="from", default=None)
+ 64    from_: Optional[List[str]] = Field(alias="to", default=None)
+ 65    source: Optional[List[str]] = Field(default=None)
+ 66    destination: Optional[List[str]] = Field(default=None)
+ 67    source_translation: Optional[List[str]] = Field(
+ 68        alias="source-translation", default=None
+ 69    )
+ 70    destination_translation: Optional[List[str]] = Field(
+ 71        alias="destination-translation", default=None
+ 72    )
+ 73
+ 74    source_user: Optional[List[str]] = Field(alias="source-user", default=None)
+ 75    application: Optional[List[str]] = Field(default=None)
+ 76    category: Optional[List[str]] = Field(default=None)
+ 77    service: Optional[List[str]] = Field(default=None)
+ 78
+ 79    icmp_unreachable: Optional[bool] = Field(alias="icmp-unreachable", default=None)
+ 80    log_start: Optional[bool] = Field(alias="log-start", default=None)
+ 81    log_end: Optional[bool] = Field(alias="log-end", default=None)
+ 82    negate_source: Optional[bool] = Field(alias="negate-source", default=None)
+ 83    negate_destination: Optional[bool] = Field(alias="negate-destination", default=None)
+ 84
+ 85    @field_validator(
+ 86        "tag",
+ 87        "to_",
+ 88        "from_",
+ 89        "source",
+ 90        "destination",
+ 91        "source_translation",
+ 92        "destination_translation",
+ 93        "source_user",
+ 94        "application",
+ 95        "category",
+ 96        "service",
+ 97        mode="before",
+ 98    )
+ 99    @classmethod
+100    def ensure_membership(cls, v: Any):
+101        if v is None:
+102            return None
+103        members = v.get("member") if isinstance(v, dict) else v
+104        if isinstance(members, str):
+105            members = [members]
+106        return members
+
+ + +
+
+ +
+ + class + RuleHit(pydantic.main.BaseModel): + + + +
+ + 
10class RuleHit(BaseModel):
+11    name: str = Field(validation_alias=AliasChoices("@name", "name"))
+12    device_group: str = Field(alias="device-group")
+13    rulebase: Literal["pre-rulebase", "post-rulebase"] = Field(alias="rulebase")
+14    type: str = Field(alias="type")
+15    state: Optional[str] = Field(alias="rule-state")
+16    modification: datetime = Field(alias="rule-modification-timestamp")
+17    creation: datetime = Field(alias="rule-creation-timestamp")
+18    all_connected: bool = Field(alias="all-connected")
+19
+20    @field_validator("modification", "creation", mode="before")
+21    @classmethod
+22    def ensure_datetime(cls, v: Any):
+23        if not isinstance(v, int):
+24            v = int(v)
+25        return datetime.fromtimestamp(v)
+26
+27    @staticmethod
+28    def from_tuple(t):
+29        device_group, rulebase, rule_type, xml = t
+30        return RuleHit.model_validate(
+31            {
+32                "device-group": device_group,
+33                "rulebase": rulebase,
+34                "type": rule_type,
+35                **xml2dict(xml)["entry"],
+36            }
+37        )
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ name: str + + +
+ + + + +
+
+
+ device_group: str + + +
+ + + + +
+
+
+ rulebase: Literal['pre-rulebase', 'post-rulebase'] + + +
+ + + + +
+
+
+ type: str + + +
+ + + + +
+
+
+ state: Optional[str] + + +
+ + + + +
+
+
+ modification: datetime.datetime + + +
+ + + + +
+
+
+ creation: datetime.datetime + + +
+ + + + +
+
+
+ all_connected: bool + + +
+ + + + +
+
+ +
+
@field_validator('modification', 'creation', mode='before')
+
@classmethod
+ + def + ensure_datetime(cls, v: Any): + + + +
+ + 
20    @field_validator("modification", "creation", mode="before")
+21    @classmethod
+22    def ensure_datetime(cls, v: Any):
+23        if not isinstance(v, int):
+24            v = int(v)
+25        return datetime.fromtimestamp(v)
+
+ + + + +
+
+ +
+
@staticmethod
+ + def + from_tuple(t): + + + +
+ + 
27    @staticmethod
+28    def from_tuple(t):
+29        device_group, rulebase, rule_type, xml = t
+30        return RuleHit.model_validate(
+31            {
+32                "device-group": device_group,
+33                "rulebase": rulebase,
+34                "type": rule_type,
+35                **xml2dict(xml)["entry"],
+36            }
+37        )
+
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@name', 'name'])), 'device_group': FieldInfo(annotation=str, required=True, alias='device-group', alias_priority=2), 'rulebase': FieldInfo(annotation=Literal['pre-rulebase', 'post-rulebase'], required=True, alias='rulebase', alias_priority=2), 'type': FieldInfo(annotation=str, required=True, alias='type', alias_priority=2), 'state': FieldInfo(annotation=Union[str, NoneType], required=True, alias='rule-state', alias_priority=2), 'modification': FieldInfo(annotation=datetime, required=True, alias='rule-modification-timestamp', alias_priority=2), 'creation': FieldInfo(annotation=datetime, required=True, alias='rule-creation-timestamp', alias_priority=2), 'all_connected': FieldInfo(annotation=bool, required=True, alias='all-connected', alias_priority=2)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+
+
+
+
+ +
+ + class + RuleUse(pydantic.main.BaseModel): + + + +
+ + 
 40class RuleUse(BaseModel):
+ 41    model_config = ConfigDict(extra="allow")
+ 42    name: str = Field(validation_alias=AliasChoices("@name", "name"))
+ 43    description: Optional[str] = Field(default=None)
+ 44    uuid: str = Field(validation_alias=AliasChoices("@uuid", "uuid"))
+ 45    state: Optional[str] = Field(alias="rule-state")
+ 46    bytes: Optional[int] = Field(default=None)
+ 47    group_tag: Optional[str] = Field(alias="group-tag", default=None)
+ 48    tag: Optional[List[str]] = Field(default=None)
+ 49    disabled: Optional[bool] = Field(default=None)
+ 50    rule_type: Optional[Literal["interzone", "universal"]] = Field(
+ 51        alias="rule-type", default=None
+ 52    )
+ 53    nat_type: Optional[Literal["ipv4", "ipv6"]] = Field(alias="nat-type", default=None)
+ 54    modification: datetime = Field(alias="rule-modification-timestamp")
+ 55    creation: datetime = Field(alias="rule-creation-timestamp")
+ 56
+ 57    action: Optional[Union[Literal["allow", "deny", "reset-client"], dict]] = Field(
+ 58        default=None
+ 59    )
+ 60    to_interface: str = Field(alias="to-interface", default=None)
+ 61    protocol: Optional[Literal["tcp", "udp"]] = Field(default=None)
+ 62    port: Optional[str] = Field(default=None)  # Can be a port range
+ 63
+ 64    to_: Optional[List[str]] = Field(alias="from", default=None)
+ 65    from_: Optional[List[str]] = Field(alias="to", default=None)
+ 66    source: Optional[List[str]] = Field(default=None)
+ 67    destination: Optional[List[str]] = Field(default=None)
+ 68    source_translation: Optional[List[str]] = Field(
+ 69        alias="source-translation", default=None
+ 70    )
+ 71    destination_translation: Optional[List[str]] = Field(
+ 72        alias="destination-translation", default=None
+ 73    )
+ 74
+ 75    source_user: Optional[List[str]] = Field(alias="source-user", default=None)
+ 76    application: Optional[List[str]] = Field(default=None)
+ 77    category: Optional[List[str]] = Field(default=None)
+ 78    service: Optional[List[str]] = Field(default=None)
+ 79
+ 80    icmp_unreachable: Optional[bool] = Field(alias="icmp-unreachable", default=None)
+ 81    log_start: Optional[bool] = Field(alias="log-start", default=None)
+ 82    log_end: Optional[bool] = Field(alias="log-end", default=None)
+ 83    negate_source: Optional[bool] = Field(alias="negate-source", default=None)
+ 84    negate_destination: Optional[bool] = Field(alias="negate-destination", default=None)
+ 85
+ 86    @field_validator(
+ 87        "tag",
+ 88        "to_",
+ 89        "from_",
+ 90        "source",
+ 91        "destination",
+ 92        "source_translation",
+ 93        "destination_translation",
+ 94        "source_user",
+ 95        "application",
+ 96        "category",
+ 97        "service",
+ 98        mode="before",
+ 99    )
+100    @classmethod
+101    def ensure_membership(cls, v: Any):
+102        if v is None:
+103            return None
+104        members = v.get("member") if isinstance(v, dict) else v
+105        if isinstance(members, str):
+106            members = [members]
+107        return members
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+
+ model_config = +{'extra': 'allow'} + + +
+ + + + +
+
+
+ name: str + + +
+ + + + +
+
+
+ description: Optional[str] + + +
+ + + + +
+
+
+ uuid: str + + +
+ + + + +
+
+
+ state: Optional[str] + + +
+ + + + +
+
+
+ bytes: Optional[int] + + +
+ + + + +
+
+
+ group_tag: Optional[str] + + +
+ + + + +
+
+
+ tag: Optional[List[str]] + + +
+ + + + +
+
+
+ disabled: Optional[bool] + + +
+ + + + +
+
+
+ rule_type: Optional[Literal['interzone', 'universal']] + + +
+ + + + +
+
+
+ nat_type: Optional[Literal['ipv4', 'ipv6']] + + +
+ + + + +
+
+
+ modification: datetime.datetime + + +
+ + + + +
+
+
+ creation: datetime.datetime + + +
+ + + + +
+
+
+ action: Union[Literal['allow', 'deny', 'reset-client'], dict, NoneType] + + +
+ + + + +
+
+
+ to_interface: str + + +
+ + + + +
+
+
+ protocol: Optional[Literal['tcp', 'udp']] + + +
+ + + + +
+
+
+ port: Optional[str] + + +
+ + + + +
+
+
+ to_: Optional[List[str]] + + +
+ + + + +
+
+
+ from_: Optional[List[str]] + + +
+ + + + +
+
+
+ source: Optional[List[str]] + + +
+ + + + +
+
+
+ destination: Optional[List[str]] + + +
+ + + + +
+
+
+ source_translation: Optional[List[str]] + + +
+ + + + +
+
+
+ destination_translation: Optional[List[str]] + + +
+ + + + +
+
+
+ source_user: Optional[List[str]] + + +
+ + + + +
+
+
+ application: Optional[List[str]] + + +
+ + + + +
+
+
+ category: Optional[List[str]] + + +
+ + + + +
+
+
+ service: Optional[List[str]] + + +
+ + + + +
+
+
+ icmp_unreachable: Optional[bool] + + +
+ + + + +
+
+
+ log_start: Optional[bool] + + +
+ + + + +
+
+
+ log_end: Optional[bool] + + +
+ + + + +
+
+
+ negate_source: Optional[bool] + + +
+ + + + +
+
+
+ negate_destination: Optional[bool] + + +
+ + + + +
+
+ +
+
@field_validator('tag', 'to_', 'from_', 'source', 'destination', 'source_translation', 'destination_translation', 'source_user', 'application', 'category', 'service', mode='before')
+
@classmethod
+ + def + ensure_membership(cls, v: Any): + + + +
+ + 
 86    @field_validator(
+ 87        "tag",
+ 88        "to_",
+ 89        "from_",
+ 90        "source",
+ 91        "destination",
+ 92        "source_translation",
+ 93        "destination_translation",
+ 94        "source_user",
+ 95        "application",
+ 96        "category",
+ 97        "service",
+ 98        mode="before",
+ 99    )
+100    @classmethod
+101    def ensure_membership(cls, v: Any):
+102        if v is None:
+103            return None
+104        members = v.get("member") if isinstance(v, dict) else v
+105        if isinstance(members, str):
+106            members = [members]
+107        return members
+
+ + + + +
+
+
+ model_fields = + + {'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@name', 'name'])), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@uuid', 'uuid'])), 'state': FieldInfo(annotation=Union[str, NoneType], required=True, alias='rule-state', alias_priority=2), 'bytes': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'group_tag': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='group-tag', alias_priority=2), 'tag': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'rule_type': FieldInfo(annotation=Union[Literal['interzone', 'universal'], NoneType], required=False, default=None, alias='rule-type', alias_priority=2), 'nat_type': FieldInfo(annotation=Union[Literal['ipv4', 'ipv6'], NoneType], required=False, default=None, alias='nat-type', alias_priority=2), 'modification': FieldInfo(annotation=datetime, required=True, alias='rule-modification-timestamp', alias_priority=2), 'creation': FieldInfo(annotation=datetime, required=True, alias='rule-creation-timestamp', alias_priority=2), 'action': FieldInfo(annotation=Union[Literal['allow', 'deny', 'reset-client'], dict, NoneType], required=False, default=None), 'to_interface': FieldInfo(annotation=str, required=False, default=None, alias='to-interface', alias_priority=2), 'protocol': FieldInfo(annotation=Union[Literal['tcp', 'udp'], NoneType], required=False, default=None), 'port': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'to_': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='from', alias_priority=2), 'from_': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='to', alias_priority=2), 'source': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'destination': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'source_translation': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='source-translation', alias_priority=2), 'destination_translation': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='destination-translation', alias_priority=2), 'source_user': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='source-user', alias_priority=2), 'application': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'category': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'service': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'icmp_unreachable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='icmp-unreachable', alias_priority=2), 'log_start': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='log-start', alias_priority=2), 'log_end': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='log-end', alias_priority=2), 'negate_source': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='negate-source', alias_priority=2), 'negate_destination': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='negate-destination', alias_priority=2)} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+
+
+
+
+ + \ No newline at end of file diff --git a/public/pa_api/xmlapi/types/utils.html b/public/pa_api/xmlapi/types/utils.html new file mode 100644 index 0000000..67e1a98 --- /dev/null +++ b/public/pa_api/xmlapi/types/utils.html @@ -0,0 +1,1139 @@ + + + + + + + pa_api.xmlapi.types.utils API documentation + + + + + + + + + +
+
+

+pa_api.xmlapi.types.utils

+ + + + + + + 
  1import json
+  2import logging
+  3import typing
+  4from datetime import datetime
+  5from types import new_class
+  6from typing import Annotated, Any, Optional, TypeVar
+  7
+  8from pydantic import BaseModel, TypeAdapter
+  9from pydantic.functional_validators import (
+ 10    BeforeValidator,
+ 11    PlainValidator,
+ 12)
+ 13from typing_extensions import Self, TypedDict
+ 14
+ 15from pa_api.utils import first
+ 16from pa_api.xmlapi.utils import el2dict
+ 17
+ 18DATETIME_FORMAT = "%Y/%m/%d %H:%M:%S"
+ 19TIME_FORMAT = "%H:%M:%S"
+ 20NoneType: type = type(None)
+ 21
+ 22
+ 23class XMLBaseModel(BaseModel):
+ 24    @classmethod
+ 25    def from_xml(cls, xml) -> Self:
+ 26        rulebase = first(el2dict(xml).values())
+ 27        return cls.model_validate(rulebase)
+ 28
+ 29
+ 30def parse_datetime(d):
+ 31    try:
+ 32        if d is None or d == "none":
+ 33            return None
+ 34        return datetime.strptime(d, DATETIME_FORMAT)
+ 35    except Exception as e:
+ 36        logging.debug(e)
+ 37        logging.debug(f"Failed to parse {d} as datetime")
+ 38        print(d, type(d))
+ 39        raise
+ 40    return d
+ 41
+ 42
+ 43def parse_time(d):
+ 44    return datetime.strptime(d, TIME_FORMAT).time()
+ 45
+ 46
+ 47# https://docs.pydantic.dev/latest/concepts/types/#custom-types
+ 48# JobProgress = TypeAliasType('JobProgress', PlainValidator(parse_progress))
+ 49# Datetime = TypeAliasType(
+ 50#     "Datetime", Annotated[datetime, PlainValidator(parse_datetime)]
+ 51# )
+ 52Datetime = Annotated[datetime, PlainValidator(parse_datetime)]
+ 53
+ 54
+ 55def single_xpath(xml, xpath, parser=None, default=None):
+ 56    try:
+ 57        res = xml.xpath(xpath)
+ 58        res = first(res, None)
+ 59    except Exception:
+ 60        return default
+ 61    if res is None:
+ 62        return default
+ 63    if not isinstance(res, str):
+ 64        res = res.text
+ 65    if parser:
+ 66        res = parser(res)
+ 67    return res
+ 68
+ 69
+ 70pd = parse_datetime
+ 71sx = single_xpath
+ 72
+ 73
+ 74def mksx(xml):
+ 75    def single_xpath(xpath, parser=None, default=None):
+ 76        res = sx(xml, xpath, parser=parser, default=default)
+ 77        logging.debug(res)
+ 78        return res
+ 79
+ 80    return single_xpath
+ 81
+ 82
+ 83def ensure_list(v: Any) -> typing.List[Any]:
+ 84    if v is None:
+ 85        return []
+ 86    if isinstance(v, dict) and len(v) == 1 and "member" in v:
+ 87        return ensure_list(v["member"])
+ 88    if isinstance(v, list):
+ 89        return v
+ 90    return [v]
+ 91
+ 92
+ 93# https://docs.pydantic.dev/latest/concepts/types/#generics
+ 94Element = TypeVar("Element", bound=Any)
+ 95# Similar to typing.List, but ensure to always return a list
+ 96List = Annotated[typing.List[Element], BeforeValidator(ensure_list)]
+ 97
+ 98# from pydantic import TypeAdapter
+ 99# ta = TypeAdapter(List[int])
+100# print(ta.validate_python(5))
+101# print(ta.validate_python([5]))
+102# print(ta.validate_python())
+103
+104
+105def ensure_str(v: Any) -> str:
+106    if v is None:
+107        return ""
+108    if isinstance(v, dict):
+109        return v["#text"]
+110    return v
+111
+112
+113def validate_ip(v: Any) -> str:
+114    if v is None:
+115        return ""
+116    if isinstance(v, dict):
+117        return v["@name"]
+118    return v
+119
+120
+121String = Annotated[str, BeforeValidator(ensure_str)]
+122Ip = Annotated[str, BeforeValidator(validate_ip)]
+123
+124
+125def _xml2schema(values: list):
+126    types: typing.List[Any] = [
+127        t.__name__ for t in {type(v) for v in values if not isinstance(v, (dict, list))}
+128    ]
+129    list_values = [v for v in values if isinstance(v, list)]
+130    if list_values:
+131        types.append(_xml2schema([e for sublist in list_values for e in sublist]))
+132    dict_values = [v for v in values if isinstance(v, dict)]
+133    if dict_values:
+134        all_keys = {k for d in dict_values for k in d}
+135        dict_schema = {
+136            k: _xml2schema([d.get(k) for d in dict_values]) for k in all_keys
+137        }
+138        types.append(dict_schema)
+139    if not types:
+140        raise Exception("NO TYPE")
+141    if len(types) == 1:
+142        return types[0]
+143    return types
+144
+145
+146def _clean_key(k):
+147    return k.replace("@", "").replace("#", "")
+148
+149
+150def _slug(k):
+151    return _clean_key(k).replace("-", "_")
+152
+153
+154def _keyastypename(k):
+155    return "".join(p.title() for p in _clean_key(k).split("-"))
+156
+157
+158def _schematype(values: list, name: Optional[str] = None) -> type:
+159    if not name:
+160        name = "Dict"
+161    optional = None in values
+162    values = [v for v in values if v is not None]
+163    schema_types: typing.List[Any] = list(
+164        {type(v) for v in values if not isinstance(v, (dict, list))}
+165    )
+166    list_values = [v for v in values if isinstance(v, list)]
+167    if list_values:
+168        t = _schematype([e for sublist in list_values for e in sublist], name=name)
+169        schema_types.append(t)
+170    dict_values = [v for v in values if isinstance(v, dict)]
+171    if dict_values:
+172        all_keys = {k for d in dict_values for k in d}
+173        annotations = {
+174            _slug(k): _schematype(
+175                [d.get(k) for d in dict_values], name=_keyastypename(k)
+176            )
+177            for k in all_keys
+178        }
+179        t = new_class(
+180            name,
+181            (TypedDict,),
+182            None,
+183            lambda ns: ns.update({"__annotations__": annotations}),
+184        )
+185        schema_types.append(t)
+186    if not schema_types:
+187        return NoneType
+188        # raise Exception("NO TYPE")
+189
+190    final_type = (
+191        schema_types[0] if len(schema_types) == 1 else typing.Union[tuple(schema_types)]
+192    )
+193    if optional:
+194        final_type = Optional[final_type]
+195    return final_type
+196
+197
+198def xml2schema(xml):
+199    """
+200    Similar to schematype function:
+201    The result is a recursive schema that can be dumped with json.
+202    """
+203    data = el2dict(xml)
+204    return _xml2schema([data])
+205
+206
+207def schematype(data, name: Optional[str] = None):
+208    """
+209    Recursively parse the data to infer the schema.
+210    The schema is returned as a type.
+211
+212    We can dump the json schema using pydantic:
+213    TypeAdapter(schematype({"test": 5})).json_schema()
+214    """
+215    return _schematype([data], name=name)
+216
+217
+218def xml2schematype(xml):
+219    """
+220    Same to schematype function but takes an xml Element as parameter
+221    """
+222    name, data = first(el2dict(xml).items())
+223    return schematype(data, name)
+224
+225
+226def jsonschema(data, name=None, indent=4) -> str:
+227    ta = TypeAdapter(schematype(data, name))
+228    return json.dumps(ta.json_schema(), indent=indent)
+229
+230
+231def xml2jsonschema(data, indent=4) -> str:
+232    ta = TypeAdapter(xml2schematype(data))
+233    return json.dumps(ta.json_schema(), indent=indent)
+
+ + +
+
+
+ DATETIME_FORMAT = +'%Y/%m/%d %H:%M:%S' + + +
+ + + + +
+
+
+ TIME_FORMAT = +'%H:%M:%S' + + +
+ + + + +
+
+
+ + class + NoneType: + + +
+ + + + +
+
+ +
+ + class + XMLBaseModel(pydantic.main.BaseModel): + + + +
+ + 
24class XMLBaseModel(BaseModel):
+25    @classmethod
+26    def from_xml(cls, xml) -> Self:
+27        rulebase = first(el2dict(xml).values())
+28        return cls.model_validate(rulebase)
+
+ + +

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

+ +

A base class for creating Pydantic models.

+ +

Attributes: + __class_vars__: The names of classvars defined on the model. + __private_attributes__: Metadata about the private attributes of the model. + __signature__: The signature for instantiating the model.

+ +
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.
+__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.
+__pydantic_custom_init__: Whether the model has a custom `__init__` function.
+__pydantic_decorators__: Metadata containing the decorators defined on the model.
+    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.
+__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to
+    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.
+__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.
+__pydantic_post_init__: The name of the post-init method for the model, if defined.
+__pydantic_root_model__: Whether the model is a `RootModel`.
+__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.
+__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.
+
+__pydantic_extra__: An instance attribute with the values of extra fields from validation when
+    `model_config['extra'] == 'allow'`.
+__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.
+__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.
+
+
+ + +
+ +
+
@classmethod
+ + def + from_xml(cls, xml) -> typing_extensions.Self: + + + +
+ + 
25    @classmethod
+26    def from_xml(cls, xml) -> Self:
+27        rulebase = first(el2dict(xml).values())
+28        return cls.model_validate(rulebase)
+
+ + + + +
+
+
+ model_config = +{} + + +
+ + + + +
+
+
+ model_fields = +{} + + +
+ + + + +
+
+
+ model_computed_fields = +{} + + +
+ + + + +
+
+
Inherited Members
+
+
pydantic.main.BaseModel
+
BaseModel
+
model_extra
+
model_fields_set
+
model_construct
+
model_copy
+
model_dump
+
model_dump_json
+
model_json_schema
+
model_parametrized_name
+
model_post_init
+
model_rebuild
+
model_validate
+
model_validate_json
+
model_validate_strings
+
dict
+
json
+
parse_obj
+
parse_raw
+
parse_file
+
from_orm
+
construct
+
copy
+
schema
+
schema_json
+
validate
+
update_forward_refs
+ +
+
+
+
+
+ +
+ + def + parse_datetime(d): + + + +
+ + 
31def parse_datetime(d):
+32    try:
+33        if d is None or d == "none":
+34            return None
+35        return datetime.strptime(d, DATETIME_FORMAT)
+36    except Exception as e:
+37        logging.debug(e)
+38        logging.debug(f"Failed to parse {d} as datetime")
+39        print(d, type(d))
+40        raise
+41    return d
+
+ + + + +
+
+ +
+ + def + parse_time(d): + + + +
+ + 
44def parse_time(d):
+45    return datetime.strptime(d, TIME_FORMAT).time()
+
+ + + + +
+
+
+ Datetime = +typing.Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime>)] + + +
+ + + + +
+
+ +
+ + def + single_xpath(xml, xpath, parser=None, default=None): + + + +
+ + 
56def single_xpath(xml, xpath, parser=None, default=None):
+57    try:
+58        res = xml.xpath(xpath)
+59        res = first(res, None)
+60    except Exception:
+61        return default
+62    if res is None:
+63        return default
+64    if not isinstance(res, str):
+65        res = res.text
+66    if parser:
+67        res = parser(res)
+68    return res
+
+ + + + +
+
+ +
+ + def + pd(d): + + + +
+ + 
31def parse_datetime(d):
+32    try:
+33        if d is None or d == "none":
+34            return None
+35        return datetime.strptime(d, DATETIME_FORMAT)
+36    except Exception as e:
+37        logging.debug(e)
+38        logging.debug(f"Failed to parse {d} as datetime")
+39        print(d, type(d))
+40        raise
+41    return d
+
+ + + + +
+
+ +
+ + def + sx(xml, xpath, parser=None, default=None): + + + +
+ + 
56def single_xpath(xml, xpath, parser=None, default=None):
+57    try:
+58        res = xml.xpath(xpath)
+59        res = first(res, None)
+60    except Exception:
+61        return default
+62    if res is None:
+63        return default
+64    if not isinstance(res, str):
+65        res = res.text
+66    if parser:
+67        res = parser(res)
+68    return res
+
+ + + + +
+
+ +
+ + def + mksx(xml): + + + +
+ + 
75def mksx(xml):
+76    def single_xpath(xpath, parser=None, default=None):
+77        res = sx(xml, xpath, parser=parser, default=default)
+78        logging.debug(res)
+79        return res
+80
+81    return single_xpath
+
+ + + + +
+
+ +
+ + def + ensure_list(v: Any) -> List[Any]: + + + +
+ + 
84def ensure_list(v: Any) -> typing.List[Any]:
+85    if v is None:
+86        return []
+87    if isinstance(v, dict) and len(v) == 1 and "member" in v:
+88        return ensure_list(v["member"])
+89    if isinstance(v, list):
+90        return v
+91    return [v]
+
+ + + + +
+
+
+ List = +typing.Annotated[typing.List[~Element], BeforeValidator(func=<function ensure_list>)] + + +
+ + + + +
+
+ +
+ + def + ensure_str(v: Any) -> str: + + + +
+ + 
106def ensure_str(v: Any) -> str:
+107    if v is None:
+108        return ""
+109    if isinstance(v, dict):
+110        return v["#text"]
+111    return v
+
+ + + + +
+
+ +
+ + def + validate_ip(v: Any) -> str: + + + +
+ + 
114def validate_ip(v: Any) -> str:
+115    if v is None:
+116        return ""
+117    if isinstance(v, dict):
+118        return v["@name"]
+119    return v
+
+ + + + +
+
+
+ String = +typing.Annotated[str, BeforeValidator(func=<function ensure_str>)] + + +
+ + + + +
+
+
+ Ip = +typing.Annotated[str, BeforeValidator(func=<function validate_ip>)] + + +
+ + + + +
+
+ +
+ + def + xml2schema(xml): + + + +
+ + 
199def xml2schema(xml):
+200    """
+201    Similar to schematype function:
+202    The result is a recursive schema that can be dumped with json.
+203    """
+204    data = el2dict(xml)
+205    return _xml2schema([data])
+
+ + +

Similar to schematype function: +The result is a recursive schema that can be dumped with json.

+
+ + +
+
+ +
+ + def + schematype(data, name: Optional[str] = None): + + + +
+ + 
208def schematype(data, name: Optional[str] = None):
+209    """
+210    Recursively parse the data to infer the schema.
+211    The schema is returned as a type.
+212
+213    We can dump the json schema using pydantic:
+214    TypeAdapter(schematype({"test": 5})).json_schema()
+215    """
+216    return _schematype([data], name=name)
+
+ + +

Recursively parse the data to infer the schema. +The schema is returned as a type.

+ +

We can dump the json schema using pydantic: +TypeAdapter(schematype({"test": 5})).json_schema()

+
+ + +
+
+ +
+ + def + xml2schematype(xml): + + + +
+ + 
219def xml2schematype(xml):
+220    """
+221    Same to schematype function but takes an xml Element as parameter
+222    """
+223    name, data = first(el2dict(xml).items())
+224    return schematype(data, name)
+
+ + +

Same to schematype function but takes an xml Element as parameter

+
+ + +
+
+ +
+ + def + jsonschema(data, name=None, indent=4) -> str: + + + +
+ + 
227def jsonschema(data, name=None, indent=4) -> str:
+228    ta = TypeAdapter(schematype(data, name))
+229    return json.dumps(ta.json_schema(), indent=indent)
+
+ + + + +
+
+ +
+ + def + xml2jsonschema(data, indent=4) -> str: + + + +
+ + 
232def xml2jsonschema(data, indent=4) -> str:
+233    ta = TypeAdapter(xml2schematype(data))
+234    return json.dumps(ta.json_schema(), indent=indent)
+
+ + + + +
+
+ + \ No newline at end of file diff --git a/public/search.js b/public/search.js new file mode 100644 index 0000000..ecc9180 --- /dev/null +++ b/public/search.js @@ -0,0 +1,46 @@ +window.pdocSearch = (function(){ +/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();o

\n"}, "pa_api.panorama": {"fullname": "pa_api.panorama", "modulename": "pa_api.panorama", "kind": "module", "doc": "

\n"}, "pa_api.panorama.Panorama": {"fullname": "pa_api.panorama.Panorama", "modulename": "pa_api.panorama", "qualname": "Panorama", "kind": "class", "doc": "

Wrapper class for the Panorama class from pan-os-python library:\nhttps://pan-os-python.readthedocs.io/en/latest/readme.html#features

\n\n

Added features are:

\n\n\n", "bases": "panos.panorama.Panorama"}, "pa_api.panorama.Panorama.__init__": {"fullname": "pa_api.panorama.Panorama.__init__", "modulename": "pa_api.panorama", "qualname": "Panorama.__init__", "kind": "function", "doc": "

Initialize PanDevice

\n", "signature": "(\thostname,\tapi_username=None,\tapi_password=None,\tapi_key=None,\tport=None,\t*args,\t**kwargs)"}, "pa_api.restapi": {"fullname": "pa_api.restapi", "modulename": "pa_api.restapi", "kind": "module", "doc": "

\n"}, "pa_api.restapi.PanoramaClient": {"fullname": "pa_api.restapi.PanoramaClient", "modulename": "pa_api.restapi", "qualname": "PanoramaClient", "kind": "class", "doc": "

Wrapper for the PaloAlto REST API\nResources (e.g. Addresses, Tags, ..) are grouped under their resource types.\nSee https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4

\n\n

Attributes:

\n\n
- objects: groups all the objects (Address, Tag, Service, ...)\n- policies: groups all the policies (Security, NAT, ...)\n- network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)\n- device: groups all device-related resources (only VirtualSystems)\n- panorama: groups all panorama-management-related resources (only DeviceGroups)\n
\n"}, "pa_api.restapi.PanoramaClient.__init__": {"fullname": "pa_api.restapi.PanoramaClient.__init__", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.__init__", "kind": "function", "doc": "

\n", "signature": "(domain, api_key=None, version='v10.1', verify=False, verbose=False)"}, "pa_api.restapi.PanoramaClient.objects": {"fullname": "pa_api.restapi.PanoramaClient.objects", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.objects", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaObjectsResourceType"}, "pa_api.restapi.PanoramaClient.policies": {"fullname": "pa_api.restapi.PanoramaClient.policies", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.policies", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaPoliciesResourceType"}, "pa_api.restapi.PanoramaClient.network": {"fullname": "pa_api.restapi.PanoramaClient.network", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.network", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaNetworkResourceType"}, "pa_api.restapi.PanoramaClient.device": {"fullname": "pa_api.restapi.PanoramaClient.device", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.device", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaDevicesResourceType"}, "pa_api.restapi.PanoramaClient.panorama": {"fullname": "pa_api.restapi.PanoramaClient.panorama", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.panorama", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaPanoramaResourceType"}, "pa_api.restapi.PanoramaClient.client": {"fullname": "pa_api.restapi.PanoramaClient.client", "modulename": "pa_api.restapi", "qualname": "PanoramaClient.client", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources": {"fullname": "pa_api.restapi.rest_resources", "modulename": "pa_api.restapi.rest_resources", "kind": "module", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"fullname": "pa_api.restapi.rest_resources.PanoramaDevicesResourceType", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaDevicesResourceType", "kind": "class", "doc": "

Represent the 'Devices' subsection in the API.

\n", "bases": "PanoramaResourceType"}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"fullname": "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaDevicesResourceType.__init__", "kind": "function", "doc": "

\n", "signature": "(client, domain, version='v10.1')"}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"fullname": "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaDevicesResourceType.DEFAULT_PARAMS", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar", "default_value": "{'location': 'template'}"}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"fullname": "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaDevicesResourceType.resource_type", "kind": "variable", "doc": "

\n", "default_value": "'Device'"}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"fullname": "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaDevicesResourceType.VirtualSystems", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType", "kind": "class", "doc": "

Represent the 'Network' subsection in the API.

\n", "bases": "PanoramaResourceType"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.__init__", "kind": "function", "doc": "

\n", "signature": "(client, domain, version='v10.1')"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.DEFAULT_PARAMS", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar", "default_value": "{'location': 'template'}"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.resource_type", "kind": "variable", "doc": "

\n", "default_value": "'Network'"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.EthernetInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.AggregateEthernetInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.VLANInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.LoopbackInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.TunnelIntefaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.SDWANInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.Zones", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.VLANs", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.VirtualWires", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.VirtualRouters", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.IPSecTunnels", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GRETunnels", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.DHCPServers", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.DHCPRelays", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.DNSProxies", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectPortals", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectGateways", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectClientlessApps", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.QoSInterfaces", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.LLDP", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.IKEGatewayNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.IKECryptoNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.MonitorNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.QoSNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.LLDPNetworkProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaNetworkResourceType.SDWANInterfaceProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType", "kind": "class", "doc": "

Represent the 'Objects' subsection in the API.

\n", "bases": "PanoramaResourceType"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.__init__", "kind": "function", "doc": "

\n", "signature": "(client, domain, version='v10.1')"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.resource_type", "kind": "variable", "doc": "

\n", "default_value": "'Objects'"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Addresses", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.AddressGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Regions", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Applications", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.ApplicationGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.ApplicationFilters", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Services", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.ServiceGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Tags", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.GlobalProtectHIPObjects", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.GlobalProtectHIPProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.ExternalDynamicLists", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.CustomDataPatterns", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.CustomSpywareSignatures", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.CustomVulnerabilitySignatures", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.CustomURLCategories", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.AntivirusSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.AntiSpywareSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.URLFilteringSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.FileBlockingSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.DataFilteringSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.DoSProtectionSecurityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.SecurityProfileGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.LogForwardingProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.AuthenticationEnforcements", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.DecryptionProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.DecryptionForwardingProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.Schedules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.SDWANPathQualityProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"fullname": "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"fullname": "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPanoramaResourceType", "kind": "class", "doc": "

\n", "bases": "PanoramaResourceType"}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"fullname": "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPanoramaResourceType.__init__", "kind": "function", "doc": "

\n", "signature": "(client, domain, version='v10.1')"}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"fullname": "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPanoramaResourceType.resource_type", "kind": "variable", "doc": "

\n", "default_value": "'Panorama'"}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"fullname": "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPanoramaResourceType.DeviceGroups", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType", "kind": "class", "doc": "

Represent the 'Policies' subsection in the API.

\n", "bases": "PanoramaResourceType"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.__init__", "kind": "function", "doc": "

\n", "signature": "(client, domain, version='v10.1')"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.resource_type", "kind": "variable", "doc": "

\n", "default_value": "'Policies'"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SecurityPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SecurityPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SecurityRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.NATPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.NATPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.NATRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.QoSPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.QoSPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.QoSRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.PolicyBasedForwardingRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DecryptionPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DecryptionPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DecryptionRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.TunnelInspectionPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.TunnelInspectionPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.TunnelInspectionRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.ApplicationOverridePreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.ApplicationOverridePostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.ApplicationOverrideRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.AuthenticationPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.AuthenticationPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.AuthenticationRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DoSPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DoSPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.DoSRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SDWANPreRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SDWANPostRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"fullname": "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules", "modulename": "pa_api.restapi.rest_resources", "qualname": "PanoramaPoliciesResourceType.SDWANRules", "kind": "variable", "doc": "

\n"}, "pa_api.restapi.restapi": {"fullname": "pa_api.restapi.restapi", "modulename": "pa_api.restapi.restapi", "kind": "module", "doc": "

\n"}, "pa_api.restapi.restapi.PanoramaClient": {"fullname": "pa_api.restapi.restapi.PanoramaClient", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient", "kind": "class", "doc": "

Wrapper for the PaloAlto REST API\nResources (e.g. Addresses, Tags, ..) are grouped under their resource types.\nSee https://docs.paloaltonetworks.com/pan-os/10-1/pan-os-panorama-api/get-started-with-the-pan-os-rest-api/access-the-rest-api#id0e536ca4-6154-4188-b70f-227c2c113ec4

\n\n

Attributes:

\n\n
- objects: groups all the objects (Address, Tag, Service, ...)\n- policies: groups all the policies (Security, NAT, ...)\n- network: groups all the network resources (e.g. EthernetInterfaces, VLANInterfaces, ...)\n- device: groups all device-related resources (only VirtualSystems)\n- panorama: groups all panorama-management-related resources (only DeviceGroups)\n
\n"}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"fullname": "pa_api.restapi.restapi.PanoramaClient.__init__", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.__init__", "kind": "function", "doc": "

\n", "signature": "(domain, api_key=None, version='v10.1', verify=False, verbose=False)"}, "pa_api.restapi.restapi.PanoramaClient.objects": {"fullname": "pa_api.restapi.restapi.PanoramaClient.objects", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.objects", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaObjectsResourceType"}, "pa_api.restapi.restapi.PanoramaClient.policies": {"fullname": "pa_api.restapi.restapi.PanoramaClient.policies", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.policies", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaPoliciesResourceType"}, "pa_api.restapi.restapi.PanoramaClient.network": {"fullname": "pa_api.restapi.restapi.PanoramaClient.network", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.network", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaNetworkResourceType"}, "pa_api.restapi.restapi.PanoramaClient.device": {"fullname": "pa_api.restapi.restapi.PanoramaClient.device", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.device", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaDevicesResourceType"}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"fullname": "pa_api.restapi.restapi.PanoramaClient.panorama", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.panorama", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.restapi.rest_resources.PanoramaPanoramaResourceType"}, "pa_api.restapi.restapi.PanoramaClient.client": {"fullname": "pa_api.restapi.restapi.PanoramaClient.client", "modulename": "pa_api.restapi.restapi", "qualname": "PanoramaClient.client", "kind": "variable", "doc": "

\n"}, "pa_api.xmlapi": {"fullname": "pa_api.xmlapi", "modulename": "pa_api.xmlapi", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.XMLApi": {"fullname": "pa_api.xmlapi.XMLApi", "modulename": "pa_api.xmlapi", "qualname": "XMLApi", "kind": "class", "doc": "

\n"}, "pa_api.xmlapi.XMLApi.__init__": {"fullname": "pa_api.xmlapi.XMLApi.__init__", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.__init__", "kind": "function", "doc": "

\n", "signature": "(\thost=None,\tapi_key=None,\tispanorama=None,\tverify=False,\ttimeout=None,\tlogger=None)"}, "pa_api.xmlapi.XMLApi.logger": {"fullname": "pa_api.xmlapi.XMLApi.logger", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.logger", "kind": "variable", "doc": "

\n"}, "pa_api.xmlapi.XMLApi.export_configuration": {"fullname": "pa_api.xmlapi.XMLApi.export_configuration", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.export_configuration", "kind": "function", "doc": "

\n", "signature": "(\tself,\tverify=None,\ttimeout=None) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.export_device_state": {"fullname": "pa_api.xmlapi.XMLApi.export_device_state", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.export_device_state", "kind": "function", "doc": "

\n", "signature": "(\tself,\tverify=None,\ttimeout=None) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.generate_apikey": {"fullname": "pa_api.xmlapi.XMLApi.generate_apikey", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.generate_apikey", "kind": "function", "doc": "

Generate a new API-Key for the user connected.

\n", "signature": "(self, username, password: str) -> str:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.api_version": {"fullname": "pa_api.xmlapi.XMLApi.api_version", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.api_version", "kind": "function", "doc": "

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.configuration": {"fullname": "pa_api.xmlapi.XMLApi.configuration", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.configuration", "kind": "function", "doc": "

\n", "signature": "(\tself,\txpath,\taction='get',\tmethod='GET',\tparams=None,\tremove_blank_text=True):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.operation": {"fullname": "pa_api.xmlapi.XMLApi.operation", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.operation", "kind": "function", "doc": "

\n", "signature": "(self, cmd, method='POST', params=None, remove_blank_text=True):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.ispanorama": {"fullname": "pa_api.xmlapi.XMLApi.ispanorama", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.ispanorama", "kind": "variable", "doc": "

\n"}, "pa_api.xmlapi.XMLApi.get_tree": {"fullname": "pa_api.xmlapi.XMLApi.get_tree", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_tree", "kind": "function", "doc": "

Return the running configuration\nThe differences with running_config are not known

\n", "signature": "(self, extended=False) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_rule_use": {"fullname": "pa_api.xmlapi.XMLApi.get_rule_use", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_rule_use", "kind": "function", "doc": "

\n", "signature": "(self, tree=None, max_threads: Optional[int] = None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"fullname": "pa_api.xmlapi.XMLApi.get_rule_hit_count", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_rule_hit_count", "kind": "function", "doc": "

\n", "signature": "(self, tree=None, max_threads=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get": {"fullname": "pa_api.xmlapi.XMLApi.get", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get", "kind": "function", "doc": "

This will retrieve the xml definition based on the xpath\nThe xpath doesn't need to be exact\nand can select multiple values at once.\nStill, it must at least speciy /config at is begining

\n", "signature": "(self, xpath: str):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.delete": {"fullname": "pa_api.xmlapi.XMLApi.delete", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.delete", "kind": "function", "doc": "

This will REMOVE the xml definition at the provided xpath.\nThe xpath must be exact.

\n", "signature": "(self, xpath: str):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.create": {"fullname": "pa_api.xmlapi.XMLApi.create", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.create", "kind": "function", "doc": "

This will ADD the xml definition\nINSIDE the element at the provided xpath.\nThe xpath must be exact.

\n", "signature": "(self, xpath: str, xml_definition):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.update": {"fullname": "pa_api.xmlapi.XMLApi.update", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.update", "kind": "function", "doc": "

This will REPLACE the xml definition\nINSTEAD of the element at the provided xpath\nThe xpath must be exact.\nNb: We can pull the whole config, update it locally,\nand push the final result

\n", "signature": "(self, xpath: str, xml_definition):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.revert_changes": {"fullname": "pa_api.xmlapi.XMLApi.revert_changes", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.revert_changes", "kind": "function", "doc": "

Revert all the changes made on Panorama.\nNOTE:

\n\n
    \n
  • This only applies on non-commited changes.
    • \n
  • This revert everything (not scoped by users)
    • \n
\n\n

skip_validated: Do not revert changes that were validated

\n", "signature": "(self, skip_validated: bool = False):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.validate_changes": {"fullname": "pa_api.xmlapi.XMLApi.validate_changes", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.validate_changes", "kind": "function", "doc": "

Validated all the changes currently made

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"fullname": "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_push_scope_devicegroups", "kind": "function", "doc": "

Gives detailed information about pending changes\n(e.g. xpath, owner, action, ...)

\n", "signature": "(self, admin=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"fullname": "pa_api.xmlapi.XMLApi.uncommited_changes", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.uncommited_changes", "kind": "function", "doc": "

Gives detailed information about pending changes\n(e.g. xpath, owner, action, ...)

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"fullname": "pa_api.xmlapi.XMLApi.uncommited_changes_summary", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.uncommited_changes_summary", "kind": "function", "doc": "

Only gives the concern device groups

\n", "signature": "(self, admin=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.pending_changes": {"fullname": "pa_api.xmlapi.XMLApi.pending_changes", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.pending_changes", "kind": "function", "doc": "

Result content is either 'yes' or 'no'

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.save_config": {"fullname": "pa_api.xmlapi.XMLApi.save_config", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.save_config", "kind": "function", "doc": "

Create a named snapshot of the current configuration

\n", "signature": "(self, name):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.save_device_state": {"fullname": "pa_api.xmlapi.XMLApi.save_device_state", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.save_device_state", "kind": "function", "doc": "

Create a snapshot of the current device state

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"fullname": "pa_api.xmlapi.XMLApi.get_named_configuration", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_named_configuration", "kind": "function", "doc": "

Get the configuration from a named snapshot as an XML object

\n", "signature": "(self, name):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.candidate_config": {"fullname": "pa_api.xmlapi.XMLApi.candidate_config", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.candidate_config", "kind": "function", "doc": "

Get the configuration to be commited as an XML object

\n", "signature": "(self) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.running_config": {"fullname": "pa_api.xmlapi.XMLApi.running_config", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.running_config", "kind": "function", "doc": "

Get the current running configuration as an XML object

\n", "signature": "(self) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_jobs": {"fullname": "pa_api.xmlapi.XMLApi.get_jobs", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_jobs", "kind": "function", "doc": "

Get information of job(s)\nRetrieve all jobs by default.

\n\n

If job_id is provided, then only retrieve the job requested.

\n", "signature": "(\tself,\tjob_ids: Union[NoneType, str, List[str]] = None) -> List[pa_api.xmlapi.types.operations.job.Job]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_job": {"fullname": "pa_api.xmlapi.XMLApi.get_job", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_job", "kind": "function", "doc": "

Get information of job(s)\nRetrieve all jobs by default.

\n\n

If job_id is provided, then only retrieve the job requested.

\n", "signature": "(self, job_id) -> pa_api.xmlapi.types.operations.job.Job:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_versions": {"fullname": "pa_api.xmlapi.XMLApi.get_versions", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_versions", "kind": "function", "doc": "

Get the versions informations

\n", "signature": "(self) -> List[pa_api.xmlapi.types.operations.software.SoftwareVersion]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"fullname": "pa_api.xmlapi.XMLApi.wait_job_completion", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.wait_job_completion", "kind": "function", "doc": "

Block until the job complete.

\n\n

job_id: the job to wait upon\nwaiter: a generator that yield when a new query must be done.\n see wait function (the default waiter) for an example

\n", "signature": "(self, job_id: str, waiter=None) -> pa_api.xmlapi.types.operations.job.Job:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"fullname": "pa_api.xmlapi.XMLApi.raw_get_pending_jobs", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.raw_get_pending_jobs", "kind": "function", "doc": "

Get all the jobs that are pending as a XML object

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.commit_changes": {"fullname": "pa_api.xmlapi.XMLApi.commit_changes", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.commit_changes", "kind": "function", "doc": "

Commit all changes

\n", "signature": "(self, force: bool = False):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.add_config_lock": {"fullname": "pa_api.xmlapi.XMLApi.add_config_lock", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.add_config_lock", "kind": "function", "doc": "

\n", "signature": "(self, comment=None, vsys='shared', no_exception=False) -> bool:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"fullname": "pa_api.xmlapi.XMLApi.remove_config_lock", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.remove_config_lock", "kind": "function", "doc": "

\n", "signature": "(self, vsys='shared', no_exception=False) -> bool:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"fullname": "pa_api.xmlapi.XMLApi.add_commit_lock", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.add_commit_lock", "kind": "function", "doc": "

\n", "signature": "(self, comment=None, vsys='shared', no_exception=False) -> bool:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"fullname": "pa_api.xmlapi.XMLApi.remove_commit_lock", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.remove_commit_lock", "kind": "function", "doc": "

\n", "signature": "(self, vsys='shared', no_exception=False) -> bool:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.set_ha_status": {"fullname": "pa_api.xmlapi.XMLApi.set_ha_status", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.set_ha_status", "kind": "function", "doc": "

Activate or Deactivate (suspend) the HA pair.

\n", "signature": "(self, active: bool = True, target: Optional[str] = None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"fullname": "pa_api.xmlapi.XMLApi.set_ha_preemption", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.set_ha_preemption", "kind": "function", "doc": "

NOT WORKING:\nThere is currently no way to deactivate the preemption using the API.

\n", "signature": "(self, active=True, target=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_ha_info": {"fullname": "pa_api.xmlapi.XMLApi.get_ha_info", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_ha_info", "kind": "function", "doc": "

Get the current state of a HA pair as a python object.

\n", "signature": "(\tself,\tstate_only=False,\ttarget=None) -> pa_api.xmlapi.types.operations.device.HAInfo:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"fullname": "pa_api.xmlapi.XMLApi.get_ha_pairs", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_ha_pairs", "kind": "function", "doc": "

Retrieve a tuple containing 2 values:

\n\n
    \n
  1. The list of HA pairs and their members
    2. \n
  2. A list of devices that are not part of a HA pair
    3. \n
\n", "signature": "(\tself,\tconnected=True) -> Tuple[List[Tuple[pa_api.xmlapi.types.operations.device.Device, Optional[pa_api.xmlapi.types.operations.device.Device]]], List[pa_api.xmlapi.types.operations.device.Device]]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"fullname": "pa_api.xmlapi.XMLApi.get_ha_pairs_map", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_ha_pairs_map", "kind": "function", "doc": "

Same as get_ha_pairs, but the ha_pairs are return as a map.\nThis provides an easier and more readable lookup to find a pair:

\n\n

mapping, _ = client.get_ha_pairs_map()\nserial = \"12345\"\npair_of_serial = mapping[serial]

\n", "signature": "(self, connected=True):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"fullname": "pa_api.xmlapi.XMLApi.get_panorama_status", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_panorama_status", "kind": "function", "doc": "

Get the current status of Panorama server.

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"fullname": "pa_api.xmlapi.XMLApi.raw_get_local_panorama", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.raw_get_local_panorama", "kind": "function", "doc": "

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"fullname": "pa_api.xmlapi.XMLApi.get_local_panorama_ip", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_local_panorama_ip", "kind": "function", "doc": "

\n", "signature": "(self) -> Optional[str]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_devices": {"fullname": "pa_api.xmlapi.XMLApi.get_devices", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_devices", "kind": "function", "doc": "

Return the list of device known from Panorama as a python structure.\nNOTE: This only works if the client is a Panorama server.

\n\n

connected: only returns the devices that are connected

\n", "signature": "(\tself,\tconnected=False) -> List[pa_api.xmlapi.types.operations.device.Device]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"fullname": "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_plan_dg_hierarchy", "kind": "function", "doc": "

Return the hierarchy of device groups as a dict.\nThe keys are the names of the device groups.

\n\n

The values are the children device groups and depends on the recursive parameter.\nrecursive: if False, the values are only the direct children of the device group.\n Otherwise, the values are all the descendant device groups.

\n", "signature": "(self, recursive=False):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"fullname": "pa_api.xmlapi.XMLApi.get_devicegroups_name", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_devicegroups_name", "kind": "function", "doc": "

This returns the names of the devicegroups:

\n\n
    \n
  • parents: the returned list will only contain children of the provided parents (parents included)
    • \n
  • with_devices: the returned list will only contain devicegroups that have direct devices under them
    • \n
\n", "signature": "(self, parents=None, with_connected_devices=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_addresses": {"fullname": "pa_api.xmlapi.XMLApi.get_addresses", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_addresses", "kind": "function", "doc": "

Return the list of addresses known from Panorama as a python structure.\nNOTE: This only works if the client is a Firewall.

\n", "signature": "(self) -> List[pa_api.xmlapi.types.config.address.Address]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"fullname": "pa_api.xmlapi.XMLApi.get_routing_tables", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_routing_tables", "kind": "function", "doc": "

Return the list of interface known from Panorama as a python structure.\nNOTE: This only works if the client is a Firewall.

\n", "signature": "(\tself) -> List[pa_api.xmlapi.types.config.routing.routing_table.RoutingTable]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_interfaces": {"fullname": "pa_api.xmlapi.XMLApi.get_interfaces", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_interfaces", "kind": "function", "doc": "

Return the list of interface known from Panorama as a python structure.\nNOTE: This only works if the client is a Firewall.

\n", "signature": "(self) -> List[pa_api.xmlapi.types.config.interface.Interface]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_zones": {"fullname": "pa_api.xmlapi.XMLApi.get_zones", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_zones", "kind": "function", "doc": "

Return the list of zones known from Panorama as a python structure.\nNOTE: This only works if the client is a Firewall.

\n", "signature": "(self) -> <cyfunction Element at 0x7ef48ad6e670>:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"fullname": "pa_api.xmlapi.XMLApi.get_templates_sync_status", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_templates_sync_status", "kind": "function", "doc": "

Return the synchronization status the templates per devices\nA device is in sync if it is up-to-date with the current version on Panorama.\nNOTE: This only works on Panorama.

\n\n

The result is a list of tuple of 3 values:

\n\n
    \n
  1. the template's name
    2. \n
  2. the device's name
    3. \n
  3. the sync status
    4. \n
\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"fullname": "pa_api.xmlapi.XMLApi.get_vpn_flows", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.get_vpn_flows", "kind": "function", "doc": "

Returns the VPN flow information as a python structure.\nNOTE: This only works on Panorama server, not firewalls

\n", "signature": "(self, name=None):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.system_info": {"fullname": "pa_api.xmlapi.XMLApi.system_info", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.system_info", "kind": "function", "doc": "

Returns informations about the system as a XML object.

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.system_resources": {"fullname": "pa_api.xmlapi.XMLApi.system_resources", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.system_resources", "kind": "function", "doc": "

Get the system resouces as a string.\nThe string is the raw output of a ps command.

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.download_software": {"fullname": "pa_api.xmlapi.XMLApi.download_software", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.download_software", "kind": "function", "doc": "

Download the software version on the device.\nversion: the software version to download

\n\n

Returns the download job's ID in case of successful launch,\nNone is returned otherwise.

\n", "signature": "(self, version) -> Optional[str]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.install_software": {"fullname": "pa_api.xmlapi.XMLApi.install_software", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.install_software", "kind": "function", "doc": "

Install the software version on the device.\nversion: the software version to install

\n\n

Returns the download job's ID in case of successful launch,\nNone is returned otherwise.

\n", "signature": "(\tself,\tversion: Union[NoneType, str, pa_api.xmlapi.types.operations.software.SoftwareVersion]) -> Optional[str]:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.restart": {"fullname": "pa_api.xmlapi.XMLApi.restart", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.restart", "kind": "function", "doc": "

Restart the device

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"fullname": "pa_api.xmlapi.XMLApi.automatic_download_software", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.automatic_download_software", "kind": "function", "doc": "

Automatically download the requested software version.\nif the version is not provided, it defaults to the latest one.

\n\n

NOTE: This does not do the installation.\nThis is usefull to download in anticipation of the upgrade.\nFor automatic install, see automatic_software_upgrade

\n", "signature": "(\tself,\tversion: Optional[str] = None) -> pa_api.xmlapi.types.operations.software.SoftwareVersion:", "funcdef": "def"}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"fullname": "pa_api.xmlapi.XMLApi.automatic_software_upgrade", "modulename": "pa_api.xmlapi", "qualname": "XMLApi.automatic_software_upgrade", "kind": "function", "doc": "

Automatically download and install the requested software version.\nif the version is not provided, it defaults to the latest one.

\n\n

NOTE: This does the software install and restart by default.\nIf you only want to download, prefer to use automatic_download_software method,\nor set install=False. See the parameters for more information.

\n\n

install: install the software after the download\nrestart: restart the device after the installation. This option is ignored if install=False

\n", "signature": "(\tself,\tversion: Optional[str] = None,\tinstall: bool = True,\trestart: bool = True):", "funcdef": "def"}, "pa_api.xmlapi.types": {"fullname": "pa_api.xmlapi.types", "modulename": "pa_api.xmlapi.types", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config": {"fullname": "pa_api.xmlapi.types.config", "modulename": "pa_api.xmlapi.types.config", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.address": {"fullname": "pa_api.xmlapi.types.config.address", "modulename": "pa_api.xmlapi.types.config.address", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.address.IPNetwork": {"fullname": "pa_api.xmlapi.types.config.address.IPNetwork", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "IPNetwork", "kind": "variable", "doc": "

\n", "default_value": "typing.Union[ipaddress.IPv4Network, ipaddress.IPv6Network]"}, "pa_api.xmlapi.types.config.address.get_ip_network": {"fullname": "pa_api.xmlapi.types.config.address.get_ip_network", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "get_ip_network", "kind": "function", "doc": "

\n", "signature": "(ip_netmask):", "funcdef": "def"}, "pa_api.xmlapi.types.config.address.Address": {"fullname": "pa_api.xmlapi.types.config.address.Address", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.address.Address.name": {"fullname": "pa_api.xmlapi.types.config.address.Address.name", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.address.Address.type": {"fullname": "pa_api.xmlapi.types.config.address.Address.type", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.type", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.address.Address.prefix": {"fullname": "pa_api.xmlapi.types.config.address.Address.prefix", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.prefix", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"fullname": "pa_api.xmlapi.types.config.address.Address.ip_netmask", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.ip_netmask", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"fullname": "pa_api.xmlapi.types.config.address.Address.ip_network", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.ip_network", "kind": "variable", "doc": "

\n", "annotation": ": Union[ipaddress.IPv4Network, ipaddress.IPv6Network, NoneType]"}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"fullname": "pa_api.xmlapi.types.config.address.Address.ip_range", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.ip_range", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"fullname": "pa_api.xmlapi.types.config.address.Address.fqdn", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.fqdn", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.address.Address.tags": {"fullname": "pa_api.xmlapi.types.config.address.Address.tags", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"fullname": "pa_api.xmlapi.types.config.address.Address.validate_tags", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.validate_tags", "kind": "function", "doc": "

\n", "signature": "(\tcls,\tv) -> Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"fullname": "pa_api.xmlapi.types.config.address.Address.validate_ip_network", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.validate_ip_network", "kind": "function", "doc": "

\n", "signature": "(self) -> typing_extensions.Self:", "funcdef": "def"}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"fullname": "pa_api.xmlapi.types.config.address.Address.validate_type", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.validate_type", "kind": "function", "doc": "

\n", "signature": "(self) -> typing_extensions.Self:", "funcdef": "def"}, "pa_api.xmlapi.types.config.address.Address.model_config": {"fullname": "pa_api.xmlapi.types.config.address.Address.model_config", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"fullname": "pa_api.xmlapi.types.config.address.Address.model_fields", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'prefix': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ip_netmask': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='ip-netmask', alias_priority=2, validation_alias=AliasChoices(choices=[AliasPath(path=['ip-netmask', '#text']), 'ip-netmask'])), 'ip_network': FieldInfo(annotation=Union[IPv4Network, IPv6Network, NoneType], required=False, default=None), 'ip_range': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='ip-range', alias_priority=2), 'fqdn': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.address.Address.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "Address.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.address.find_addresses": {"fullname": "pa_api.xmlapi.types.config.address.find_addresses", "modulename": "pa_api.xmlapi.types.config.address", "qualname": "find_addresses", "kind": "function", "doc": "

\n", "signature": "(tree):", "funcdef": "def"}, "pa_api.xmlapi.types.config.devicegroup": {"fullname": "pa_api.xmlapi.types.config.devicegroup", "modulename": "pa_api.xmlapi.types.config.devicegroup", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup", "kind": "class", "doc": "

This is used to parse the output of the running configuration.

\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.devices", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.addresses", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.address.Address], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.post_rulebase", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.rulebase.RuleBase]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.pre_rulebase", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.rulebase.RuleBase]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.iter_rulebases", "kind": "function", "doc": "

\n", "signature": "(self):", "funcdef": "def"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'devices': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['devices', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'addresses': FieldInfo(annotation=List[Address], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['address', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'post_rulebase': FieldInfo(annotation=Union[RuleBase, NoneType], required=False, default=None, alias_priority=2, validation_alias='post-rulebase'), 'pre_rulebase': FieldInfo(annotation=Union[RuleBase, NoneType], required=False, default=None, alias_priority=2, validation_alias='pre-rulebase'), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.devicegroup", "qualname": "DeviceGroup.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface": {"fullname": "pa_api.xmlapi.types.config.interface", "modulename": "pa_api.xmlapi.types.config.interface", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"fullname": "pa_api.xmlapi.types.config.interface.get_ip_network", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "get_ip_network", "kind": "function", "doc": "

\n", "signature": "(ip_netmask):", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'ignore'}"}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.inttype", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.parent", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.parent", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.comment", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.untagged_sub_interface", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.link_state", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.link_state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.link_speed", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.link_duplex", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.aggregate_group", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'inttype': FieldInfo(annotation=str, required=True), 'parent': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'name': FieldInfo(annotation=str, required=True), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, metadata=[BeforeValidator(func=<function ensure_list>)]), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, metadata=[BeforeValidator(func=<function ensure_list>)]), 'link_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'link_speed': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'link_duplex': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'aggregate_group': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None)}"}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "GenericInterface.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Layer2": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'layer2'"}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.units", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.units", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Layer2], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.comment", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'units': FieldInfo(annotation=List[Layer2], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer2.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Layer3": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'layer3'"}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.name", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.untagged_sub_interface", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.units", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.units", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Layer3], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.comment", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='untagged-sub-interface', alias_priority=2), 'units': FieldInfo(annotation=List[Layer3], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Layer3.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Vlan": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'vlan'"}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.name", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.units", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.units", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Vlan], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.comment", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'units': FieldInfo(annotation=List[Vlan], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Vlan.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Ethernet": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'ethernet'"}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.link_state", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.link_state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.link_speed", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.link_speed", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.link_duplex", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.aggregate_group", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.layer2", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.layer2", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.interface.Layer2]"}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.layer3", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.layer3", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.interface.Layer3]"}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'link_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-state', alias_priority=2, validation_alias=AliasPath(path=['link-state', '#text'])), 'link_speed': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-speed', alias_priority=2, validation_alias=AliasPath(path=['link-speed', '#text'])), 'link_duplex': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='link-duplex', alias_priority=2, validation_alias=AliasPath(path=['link-duplex', '#text'])), 'aggregate_group': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='aggregate-group', alias_priority=2), 'layer2': FieldInfo(annotation=Union[Layer2, NoneType], required=False, default=None, alias='layer2', alias_priority=2), 'layer3': FieldInfo(annotation=Union[Layer3, NoneType], required=False, default=None, alias='layer3', alias_priority=2), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Ethernet.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'aggregate'"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.comment", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.units", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.units", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.AggregateEthernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.layer2", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.interface.Layer2]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.layer3", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.interface.Layer3]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.untagged_sub_interface", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='#text', metadata=[BeforeValidator(func=<function ensure_str>)]), 'comment': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'units': FieldInfo(annotation=List[AggregateEthernet], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'layer2': FieldInfo(annotation=Union[Layer2, NoneType], required=False, default=None, alias='layer2', alias_priority=2), 'layer3': FieldInfo(annotation=Union[Layer3, NoneType], required=False, default=None, alias='layer3', alias_priority=2), 'untagged_sub_interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias='untagged-sub-interface', alias_priority=2), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "AggregateEthernet.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Tunnel": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'tunnel'"}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.units", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.units", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Tunnel], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[str], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.interface_management_profile", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.comment", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.mtu", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.mtu", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'units': FieldInfo(annotation=List[Tunnel], required=False, default_factory=list, alias='units', alias_priority=2, validation_alias=AliasPath(path=['units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'ip': FieldInfo(annotation=List[str], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry', '@name']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'interface_management_profile': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='interface-management-profile'), 'comment': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['comment', '#text'])), 'mtu': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['mtu', '#text']))}"}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Tunnel.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Loopback": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.inttype", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.inttype", "kind": "variable", "doc": "

\n", "annotation": ": ClassVar[str]", "default_value": "'loopback'"}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.name", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.description", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.description", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.ip", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.ip", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function validate_ip at 0x7ef48ad2b760>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.comment", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.comment", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.tags", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself,\tparent=None) -> Iterable[pa_api.xmlapi.types.config.interface.GenericInterface]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name'), 'description': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='#text'), 'ip': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['ip', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'comment': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='comment', alias_priority=2, validation_alias=AliasPath(path=['comment', '#text'])), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Loopback.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.interface.Interface": {"fullname": "pa_api.xmlapi.types.config.interface.Interface", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.model_config", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.aggregate_ethernet", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.AggregateEthernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.ethernet", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.ethernet", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Ethernet], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.loopback", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.loopback", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Loopback], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.vlan", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.vlan", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Vlan], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.tunnel", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.tunnel", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.interface.Tunnel], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.flatten", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.flatten", "kind": "function", "doc": "

\n", "signature": "(\tself) -> Annotated[List[pa_api.xmlapi.types.config.interface.GenericInterface], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]:", "funcdef": "def"}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.model_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'aggregate_ethernet': FieldInfo(annotation=List[AggregateEthernet], required=False, default_factory=list, alias='aggregate-ethernet', alias_priority=2, validation_alias=AliasPath(path=['aggregate-ethernet', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'ethernet': FieldInfo(annotation=List[Ethernet], required=False, default_factory=list, alias='ethernet', alias_priority=2, validation_alias=AliasPath(path=['ethernet', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'loopback': FieldInfo(annotation=List[Loopback], required=False, default_factory=list, alias='loopback', alias_priority=2, validation_alias=AliasPath(path=['loopback', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'vlan': FieldInfo(annotation=List[Vlan], required=False, default_factory=list, alias='vlan', alias_priority=2, validation_alias=AliasPath(path=['vlan', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'tunnel': FieldInfo(annotation=List[Tunnel], required=False, default_factory=list, alias='tunnel', alias_priority=2, validation_alias=AliasPath(path=['tunnel', 'units', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.interface", "qualname": "Interface.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.routing": {"fullname": "pa_api.xmlapi.types.config.routing", "modulename": "pa_api.xmlapi.types.config.routing", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.routing.routing_table": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.NextHop", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "NextHop", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "NextHop.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'ignore'}"}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "NextHop.ip_address", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "NextHop.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'ip_address': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='ip-address')}"}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "NextHop.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'ignore'}"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.nexthop", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.routing.routing_table.NextHop]"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.interface", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.destination", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'nexthop': FieldInfo(annotation=Union[NextHop, NoneType], required=False, default=None, alias_priority=2, validation_alias='nexthop'), 'interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='interface'), 'destination': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='destination', metadata=[BeforeValidator(func=<function ensure_str>)])}"}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "StaticRoute.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "IPv4RoutingTable", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "IPv4RoutingTable.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'ignore'}"}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "IPv4RoutingTable.static_routes", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.routing.routing_table.StaticRoute], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "IPv4RoutingTable.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'static_routes': FieldInfo(annotation=List[StaticRoute], required=True, alias_priority=2, validation_alias=AliasPath(path=['static-route', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "IPv4RoutingTable.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "RoutingTable", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "RoutingTable.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'ignore'}"}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "RoutingTable.ip", "kind": "variable", "doc": "

\n", "annotation": ": pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable"}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "RoutingTable.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'ip': FieldInfo(annotation=IPv4RoutingTable, required=True, alias_priority=2, validation_alias='ip')}"}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.routing.routing_table", "qualname": "RoutingTable.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules": {"fullname": "pa_api.xmlapi.types.config.rules", "modulename": "pa_api.xmlapi.types.config.rules", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.rules.nat": {"fullname": "pa_api.xmlapi.types.config.rules.nat", "modulename": "pa_api.xmlapi.types.config.rules.nat", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.translated_address", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.ip", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.interface", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'translated_address': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_list>)]), 'ip': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['interface-address', 'ip'])), 'interface': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['interface-address', 'interface']))}"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIPAndPort.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIP", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIP", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIP.translated_address", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIP.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIP.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'translated_address': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default=None, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DynamicIP.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"fullname": "pa_api.xmlapi.types.config.rules.nat.StaticIP", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "StaticIP", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "StaticIP.translated_address", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "StaticIP.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "StaticIP.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'translated_address': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='translated-address', metadata=[BeforeValidator(func=<function ensure_str>)])}"}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "StaticIP.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.dynamic_ip_and_port", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort]"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.dynamic_ip", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.nat.DynamicIP]"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.static_ip", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.nat.StaticIP]"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.translation", "kind": "variable", "doc": "

\n", "annotation": ": Union[pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort, pa_api.xmlapi.types.config.rules.nat.DynamicIP, pa_api.xmlapi.types.config.rules.nat.StaticIP]"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.translated_address", "kind": "variable", "doc": "

\n", "annotation": ": List[str]"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.type", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'dynamic_ip_and_port': FieldInfo(annotation=Union[DynamicIPAndPort, NoneType], required=False, default=None, alias_priority=2, validation_alias='dynamic-ip-and-port'), 'dynamic_ip': FieldInfo(annotation=Union[DynamicIP, NoneType], required=False, default=None, alias_priority=2, validation_alias='dynamic-ip'), 'static_ip': FieldInfo(annotation=Union[StaticIP, NoneType], required=False, default=None, alias_priority=2, validation_alias='static-ip')}"}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "SourceTranslation.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation.translated_address", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation.translated_port", "kind": "variable", "doc": "

\n", "annotation": ": Optional[int]"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'translated_address': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['translated-address', '#text'])), 'translated_port': FieldInfo(annotation=Union[int, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['translated-port', '#text']))}"}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "DestinationTranslation.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.name", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.uuid", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.uuid", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.disabled", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.disabled", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.description", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.group_tag", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.tags", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.services", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.services", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.source_translation", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.nat.SourceTranslation]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.destination_translation", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.nat.DestinationTranslation]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.sources", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.sources", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.destinations", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.destinations", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.to", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.to", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.from_", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.from_", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.translated_src_address", "kind": "variable", "doc": "

\n", "annotation": ": List[str]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.translated_dst_address", "kind": "variable", "doc": "

\n", "annotation": ": List[str]"}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.members", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.members", "kind": "variable", "doc": "

\n"}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.model_config", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@uuid', metadata=[BeforeValidator(func=<function ensure_str>)]), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'group_tag': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='group-tag'), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='tag', metadata=[BeforeValidator(func=<function ensure_list>)]), 'services': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='service', metadata=[BeforeValidator(func=<function ensure_list>)]), 'source_translation': FieldInfo(annotation=Union[SourceTranslation, NoneType], required=False, default=None, alias_priority=2, validation_alias='source-translation'), 'destination_translation': FieldInfo(annotation=Union[DestinationTranslation, NoneType], required=False, default=None, alias_priority=2, validation_alias='destination-translation'), 'sources': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='source', metadata=[BeforeValidator(func=<function ensure_list>)]), 'destinations': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='destination', metadata=[BeforeValidator(func=<function ensure_list>)]), 'to': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='to', metadata=[BeforeValidator(func=<function ensure_list>)]), 'from_': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias='from', metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.nat", "qualname": "NAT.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.rulebase": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase.security", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.rules.security.Security], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase.nat", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.rules.nat.NAT], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'security': FieldInfo(annotation=List[Security], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['security', 'rules', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'nat': FieldInfo(annotation=List[NAT], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['nat', 'rules', 'entry']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.rulebase", "qualname": "RuleBase.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security": {"fullname": "pa_api.xmlapi.types.config.rules.security", "modulename": "pa_api.xmlapi.types.config.rules.security", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"fullname": "pa_api.xmlapi.types.config.rules.security.ProfileSetting", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "ProfileSetting", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"fullname": "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "ProfileSetting.groups", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "ProfileSetting.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "ProfileSetting.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'groups': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['group', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)])}"}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "ProfileSetting.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.Option": {"fullname": "pa_api.xmlapi.types.config.rules.security.Option", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Option", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"fullname": "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Option.disable_server_response_inspection", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.security.Option.model_config", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Option.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Option.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Option.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'disable_server_response_inspection': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='disable-server-response-inspection')}"}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Option.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.Target": {"fullname": "pa_api.xmlapi.types.config.rules.security.Target", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Target", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"fullname": "pa_api.xmlapi.types.config.rules.security.Target.negate", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Target.negate", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.security.Target.model_config", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Target.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Target.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Target.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'negate': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None)}"}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Target.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.rules.security.Security": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.model_config", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.name", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.uuid", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.uuid", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.disabled", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.disabled", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.action", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.action", "kind": "variable", "doc": "

\n", "annotation": ": Literal['allow', 'deny', 'reset-client']"}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.to", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.to", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.from_", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.from_", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.sources", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.sources", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.destinations", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.destinations", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.source_users", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.source_users", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.services", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.services", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.applications", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.applications", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.description", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.description", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.categories", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.categories", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.tags", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.tags", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.group_tag", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.group_tag", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]]"}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.profile_settings", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.profile_settings", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[pa_api.xmlapi.types.config.rules.security.ProfileSetting], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.target", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.target", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.security.Target]"}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.option", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.option", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.rules.security.Option]"}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.rule_type", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.rule_type", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.negate_source", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.negate_source", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.negate_destination", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.negate_destination", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.log_settings", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.log_settings", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.log_start", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.log_start", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.log_end", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.log_end", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.icmp_unreachable", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.model_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='@uuid', metadata=[BeforeValidator(func=<function ensure_str>)]), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'action': FieldInfo(annotation=Literal['allow', 'deny', 'reset-client'], required=True), 'to': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['to', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'from_': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['from', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'sources': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['source', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'destinations': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['destination', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'source_users': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['source-user', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'services': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['service', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'applications': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['application', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'description': FieldInfo(annotation=str, required=False, default='', metadata=[BeforeValidator(func=<function ensure_str>)]), 'categories': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['category', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'tags': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['tag', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'group_tag': FieldInfo(annotation=Union[Annotated[str, BeforeValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='group-tag'), 'profile_settings': FieldInfo(annotation=List[ProfileSetting], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['profile-settings']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'target': FieldInfo(annotation=Union[Target, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['target'])), 'option': FieldInfo(annotation=Union[Option, NoneType], required=False, default=None), 'rule_type': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='rule-type'), 'negate_source': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='negate-source'), 'negate_destination': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='negate-destination'), 'log_settings': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-settings'), 'log_start': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-start'), 'log_end': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='log-end'), 'icmp_unreachable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias='icmp-unreachable')}"}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.rules.security", "qualname": "Security.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.zone": {"fullname": "pa_api.xmlapi.types.config.zone", "modulename": "pa_api.xmlapi.types.config.zone", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.name", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.layer3", "kind": "variable", "doc": "

\n", "annotation": ": Annotated[List[Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]], BeforeValidator(func=<function ensure_list at 0x7ef48ad2b640>)]"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.enable_packet_buffer_protection", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'layer3': FieldInfo(annotation=List[Annotated[str, BeforeValidator]], required=False, default_factory=list, alias_priority=2, validation_alias=AliasPath(path=['layer3', 'member']), metadata=[BeforeValidator(func=<function ensure_list>)]), 'enable_packet_buffer_protection': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-packet-buffer-protection', '#text']))}"}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "ZoneNetwork.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.config.zone.Zone": {"fullname": "pa_api.xmlapi.types.config.zone.Zone", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.model_config", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.config.zone.Zone.name": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.name", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.name", "kind": "variable", "doc": "

\n", "annotation": ": typing.Annotated[str, BeforeValidator(func=<function ensure_str at 0x7ef48ad2b6d0>)]"}, "pa_api.xmlapi.types.config.zone.Zone.network": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.network", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.network", "kind": "variable", "doc": "

\n", "annotation": ": Optional[pa_api.xmlapi.types.config.zone.ZoneNetwork]"}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.enable_user_identification", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.enable_device_identification", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.model_fields", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=False, default='', alias_priority=2, validation_alias='@name', metadata=[BeforeValidator(func=<function ensure_str>)]), 'network': FieldInfo(annotation=Union[ZoneNetwork, NoneType], required=False, default=None), 'enable_user_identification': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-user-identification', '#text'])), 'enable_device_identification': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['enable-device-identification', '#text']))}"}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"fullname": "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields", "modulename": "pa_api.xmlapi.types.config.zone", "qualname": "Zone.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.operations": {"fullname": "pa_api.xmlapi.types.operations", "modulename": "pa_api.xmlapi.types.operations", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.operations.device": {"fullname": "pa_api.xmlapi.types.operations.device", "modulename": "pa_api.xmlapi.types.operations.device", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.operations.device.Device": {"fullname": "pa_api.xmlapi.types.operations.device.Device", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"fullname": "pa_api.xmlapi.types.operations.device.Device.model_config", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'populate_by_name': True, 'extra': 'allow'}"}, "pa_api.xmlapi.types.operations.device.Device.serial": {"fullname": "pa_api.xmlapi.types.operations.device.Device.serial", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.serial", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.Device.connected": {"fullname": "pa_api.xmlapi.types.operations.device.Device.connected", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.connected", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.unsupported_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.unsupported_version", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"fullname": "pa_api.xmlapi.types.operations.device.Device.wildfire_rt", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.wildfire_rt", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"fullname": "pa_api.xmlapi.types.operations.device.Device.deactivated", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.deactivated", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"fullname": "pa_api.xmlapi.types.operations.device.Device.hostname", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.hostname", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"fullname": "pa_api.xmlapi.types.operations.device.Device.ip_address", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.ip_address", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"fullname": "pa_api.xmlapi.types.operations.device.Device.ipv6_address", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.ipv6_address", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"fullname": "pa_api.xmlapi.types.operations.device.Device.mac_addr", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.mac_addr", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"fullname": "pa_api.xmlapi.types.operations.device.Device.uptime", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.uptime", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.family": {"fullname": "pa_api.xmlapi.types.operations.device.Device.family", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.family", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.model": {"fullname": "pa_api.xmlapi.types.operations.device.Device.model", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.model", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.sw_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.sw_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.app_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.app_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.av_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.av_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.device_dictionary_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.wildfire_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.wildfire_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.threat_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.threat_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"fullname": "pa_api.xmlapi.types.operations.device.Device.url_db", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.url_db", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.url_filtering_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.url_filtering_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.logdb_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.logdb_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.vpnclient_package_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.global_protect_client_package_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.prev_app_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.prev_app_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.prev_av_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.prev_av_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.prev_threat_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.prev_threat_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.prev_wildfire_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"fullname": "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.prev_device_dictionary_version", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"fullname": "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.ha_peer_serial", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"fullname": "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.vpn_disable_mode", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"fullname": "pa_api.xmlapi.types.operations.device.Device.operational_mode", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.operational_mode", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"fullname": "pa_api.xmlapi.types.operations.device.Device.certificate_status", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.certificate_status", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"fullname": "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.certificate_subject_name", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"fullname": "pa_api.xmlapi.types.operations.device.Device.certificate_expiry", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.certificate_expiry", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime at 0x7ef48ae62200>)]]"}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"fullname": "pa_api.xmlapi.types.operations.device.Device.connected_at", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.connected_at", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime at 0x7ef48ae62200>)]]"}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"fullname": "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.custom_certificate_usage", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"fullname": "pa_api.xmlapi.types.operations.device.Device.multi_vsys", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.multi_vsys", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"fullname": "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.last_masterkey_push_status", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"fullname": "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.last_masterkey_push_timestamp", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"fullname": "pa_api.xmlapi.types.operations.device.Device.express_mode", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.express_mode", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"fullname": "pa_api.xmlapi.types.operations.device.Device.device_cert_present", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.device_cert_present", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"fullname": "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.device_cert_expiry_date", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"fullname": "pa_api.xmlapi.types.operations.device.Device.model_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'serial': FieldInfo(annotation=str, required=True), 'connected': FieldInfo(annotation=bool, required=True), 'unsupported_version': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='unsupported-version'), 'wildfire_rt': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='wildfire-rt'), 'deactivated': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'hostname': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ip_address': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='ip-address'), 'ipv6_address': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='ipv6-address'), 'mac_addr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='mac-addr'), 'uptime': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'family': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'model': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'sw_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='sw-version'), 'app_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='app-version'), 'av_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='av-version'), 'device_dictionary_version': FieldInfo(annotation=Union[str, NoneType], required=False, default='', alias_priority=2, validation_alias='device-dictionary-version'), 'wildfire_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='wildfire-version'), 'threat_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='threat-version'), 'url_db': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='url-db'), 'url_filtering_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='url-filtering-version'), 'logdb_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='logdb-version'), 'vpnclient_package_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='vpnclient-package-version'), 'global_protect_client_package_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='global-protect-client-package-version'), 'prev_app_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-app-version'), 'prev_av_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-av-version'), 'prev_threat_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-threat-version'), 'prev_wildfire_version': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='prev-wildfire-version'), 'prev_device_dictionary_version': FieldInfo(annotation=Union[str, NoneType], required=False, default='', alias_priority=2, validation_alias='prev-device-dictionary-version'), 'ha_peer_serial': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias=AliasPath(path=['ha', 'peer', 'serial', '#text'])), 'vpn_disable_mode': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='vpn-disable-mode'), 'operational_mode': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='operational-mode'), 'certificate_status': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-status'), 'certificate_subject_name': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-subject-name'), 'certificate_expiry': FieldInfo(annotation=Union[Annotated[datetime, PlainValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='certificate-expiry'), 'connected_at': FieldInfo(annotation=Union[Annotated[datetime, PlainValidator], NoneType], required=False, default=None, alias_priority=2, validation_alias='connected-at'), 'custom_certificate_usage': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='custom-certificate-usage'), 'multi_vsys': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='multi-vsys'), 'last_masterkey_push_status': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='last-masterkey-push-status'), 'last_masterkey_push_timestamp': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='last-masterkey-push-timestamp'), 'express_mode': FieldInfo(annotation=bool, required=True, alias_priority=2, validation_alias='express-mode'), 'device_cert_present': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias_priority=2, validation_alias='device-cert-present'), 'device_cert_expiry_date': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='device-cert-expiry-date')}"}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"fullname": "pa_api.xmlapi.types.operations.device.Device.model_computed_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "Device.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.model_config", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'populate_by_name': True, 'extra': 'allow'}"}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.name", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.id", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.id", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.gwid", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.gwid", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.inner_if", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.outer_if", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.localip", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.localip", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.peerip", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.peerip", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.state", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.state", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.mon", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.mon", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.owner", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.owner", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True), 'id': FieldInfo(annotation=int, required=True), 'gwid': FieldInfo(annotation=int, required=True), 'inner_if': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='inner-if'), 'outer_if': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias='outer-if'), 'localip': FieldInfo(annotation=str, required=True), 'peerip': FieldInfo(annotation=str, required=True), 'state': FieldInfo(annotation=str, required=True), 'mon': FieldInfo(annotation=str, required=True), 'owner': FieldInfo(annotation=str, required=True)}"}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"fullname": "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "VPNFlow.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.operations.device.HAInfo": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pa_api.xmlapi.types.utils.XMLBaseModel"}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.model_config", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'populate_by_name': True, 'extra': 'allow'}"}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.enabled", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.enabled", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.preemptive", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.preemptive", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.mode", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.mode", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.state", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.peer_state", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.peer_state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.priority", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.priority", "kind": "variable", "doc": "

\n", "annotation": ": Optional[int]"}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.peer_priority", "kind": "variable", "doc": "

\n", "annotation": ": Optional[int]"}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.is_primary", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.is_primary", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.peer_conn_status", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.mgmt_ip", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha1_ipaddr", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha1_backup_ipaddr", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha2_ipaddr", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha1_macaddress", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha1_backup_macaddress", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.ha2_macaddress", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.from_xml", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.from_xml", "kind": "function", "doc": "

\n", "signature": "(cls, xml):", "funcdef": "def"}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.model_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'enabled': FieldInfo(annotation=bool, required=True), 'preemptive': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'mode': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'peer_state': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'priority': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'peer_priority': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'is_primary': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'peer_conn_status': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'mgmt_ip': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_backup_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha2_ipaddr': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha1_backup_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'ha2_macaddress': FieldInfo(annotation=Union[str, NoneType], required=False, default=None)}"}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"fullname": "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields", "modulename": "pa_api.xmlapi.types.operations.device", "qualname": "HAInfo.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.operations.job": {"fullname": "pa_api.xmlapi.types.operations.job", "modulename": "pa_api.xmlapi.types.operations.job", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"fullname": "pa_api.xmlapi.types.operations.job.parse_tdeq", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "parse_tdeq", "kind": "function", "doc": "

\n", "signature": "(d):", "funcdef": "def"}, "pa_api.xmlapi.types.operations.job.parse_progress": {"fullname": "pa_api.xmlapi.types.operations.job.parse_progress", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "parse_progress", "kind": "function", "doc": "

\n", "signature": "(progress):", "funcdef": "def"}, "pa_api.xmlapi.types.operations.job.JobResult": {"fullname": "pa_api.xmlapi.types.operations.job.JobResult", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "JobResult", "kind": "class", "doc": "

An enumeration.

\n", "bases": "enum.Enum"}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"fullname": "pa_api.xmlapi.types.operations.job.JobResult.OK", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "JobResult.OK", "kind": "variable", "doc": "

\n", "default_value": "<JobResult.OK: 'OK'>"}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"fullname": "pa_api.xmlapi.types.operations.job.JobResult.FAIL", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "JobResult.FAIL", "kind": "variable", "doc": "

\n", "default_value": "<JobResult.FAIL: 'FAIL'>"}, "pa_api.xmlapi.types.operations.job.Job": {"fullname": "pa_api.xmlapi.types.operations.job.Job", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job", "kind": "class", "doc": "

\n"}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"fullname": "pa_api.xmlapi.types.operations.job.Job.__init__", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.__init__", "kind": "function", "doc": "

\n", "signature": "(\ttenq: datetime.datetime,\ttdeq: datetime.time,\tid: str,\tuser: str,\ttype: str,\tstatus: str,\tqueued: bool,\tstoppable: bool,\tresult: str,\ttfin: datetime.datetime,\tdescription: str,\tposition_in_queue: int,\tprogress: float,\tdetails: str,\twarnings: str)"}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"fullname": "pa_api.xmlapi.types.operations.job.Job.tenq", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.tenq", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"fullname": "pa_api.xmlapi.types.operations.job.Job.tdeq", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.tdeq", "kind": "variable", "doc": "

\n", "annotation": ": datetime.time"}, "pa_api.xmlapi.types.operations.job.Job.id": {"fullname": "pa_api.xmlapi.types.operations.job.Job.id", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.id", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.user": {"fullname": "pa_api.xmlapi.types.operations.job.Job.user", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.user", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.type": {"fullname": "pa_api.xmlapi.types.operations.job.Job.type", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.type", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.status": {"fullname": "pa_api.xmlapi.types.operations.job.Job.status", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.status", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.queued": {"fullname": "pa_api.xmlapi.types.operations.job.Job.queued", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.queued", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"fullname": "pa_api.xmlapi.types.operations.job.Job.stoppable", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.stoppable", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.job.Job.result": {"fullname": "pa_api.xmlapi.types.operations.job.Job.result", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.result", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"fullname": "pa_api.xmlapi.types.operations.job.Job.tfin", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.tfin", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.operations.job.Job.description": {"fullname": "pa_api.xmlapi.types.operations.job.Job.description", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.description", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"fullname": "pa_api.xmlapi.types.operations.job.Job.position_in_queue", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.position_in_queue", "kind": "variable", "doc": "

\n", "annotation": ": int"}, "pa_api.xmlapi.types.operations.job.Job.progress": {"fullname": "pa_api.xmlapi.types.operations.job.Job.progress", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.progress", "kind": "variable", "doc": "

\n", "annotation": ": float"}, "pa_api.xmlapi.types.operations.job.Job.details": {"fullname": "pa_api.xmlapi.types.operations.job.Job.details", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.details", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"fullname": "pa_api.xmlapi.types.operations.job.Job.warnings", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.warnings", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"fullname": "pa_api.xmlapi.types.operations.job.Job.from_xml", "modulename": "pa_api.xmlapi.types.operations.job", "qualname": "Job.from_xml", "kind": "function", "doc": "

\n", "signature": "(xml) -> Optional[pa_api.xmlapi.types.operations.job.Job]:", "funcdef": "def"}, "pa_api.xmlapi.types.operations.software": {"fullname": "pa_api.xmlapi.types.operations.software", "modulename": "pa_api.xmlapi.types.operations.software", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion", "kind": "class", "doc": "

\n"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.__init__", "kind": "function", "doc": "

\n", "signature": "(\tversion: str,\tfilename: str,\treleased_on: datetime.datetime,\tdownloaded: bool,\tcurrent: bool,\tlatest: bool,\tuploaded: bool)"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.version", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.version", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.filename", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.released_on", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.downloaded", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.current", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.current", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.latest", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.uploaded", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.from_xml", "kind": "function", "doc": "

\n", "signature": "(xml):", "funcdef": "def"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.base_minor_version", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"fullname": "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version", "modulename": "pa_api.xmlapi.types.operations.software", "qualname": "SoftwareVersion.base_major_version", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics": {"fullname": "pa_api.xmlapi.types.statistics", "modulename": "pa_api.xmlapi.types.statistics", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.statistics.RuleHit": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pydantic.main.BaseModel"}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.name", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.device_group", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.device_group", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.rulebase", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.rulebase", "kind": "variable", "doc": "

\n", "annotation": ": Literal['pre-rulebase', 'post-rulebase']"}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.type", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.type", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.state", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.modification", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.modification", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.creation", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.creation", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.all_connected", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.all_connected", "kind": "variable", "doc": "

\n", "annotation": ": bool"}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.ensure_datetime", "kind": "function", "doc": "

\n", "signature": "(cls, v: Any):", "funcdef": "def"}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.from_tuple", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.from_tuple", "kind": "function", "doc": "

\n", "signature": "(t):", "funcdef": "def"}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.model_config", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.model_fields", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@name', 'name'])), 'device_group': FieldInfo(annotation=str, required=True, alias='device-group', alias_priority=2), 'rulebase': FieldInfo(annotation=Literal['pre-rulebase', 'post-rulebase'], required=True, alias='rulebase', alias_priority=2), 'type': FieldInfo(annotation=str, required=True, alias='type', alias_priority=2), 'state': FieldInfo(annotation=Union[str, NoneType], required=True, alias='rule-state', alias_priority=2), 'modification': FieldInfo(annotation=datetime, required=True, alias='rule-modification-timestamp', alias_priority=2), 'creation': FieldInfo(annotation=datetime, required=True, alias='rule-creation-timestamp', alias_priority=2), 'all_connected': FieldInfo(annotation=bool, required=True, alias='all-connected', alias_priority=2)}"}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"fullname": "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleHit.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.statistics.RuleUse": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pydantic.main.BaseModel"}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.model_config", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.model_config", "kind": "variable", "doc": "

\n", "default_value": "{'extra': 'allow'}"}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.name", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.name", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.description", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.description", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.uuid", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.uuid", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.state", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.state", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.bytes", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.bytes", "kind": "variable", "doc": "

\n", "annotation": ": Optional[int]"}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.group_tag", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.group_tag", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.tag", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.tag", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.disabled", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.disabled", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.rule_type", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.rule_type", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Literal['interzone', 'universal']]"}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.nat_type", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.nat_type", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Literal['ipv4', 'ipv6']]"}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.modification", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.modification", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.creation", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.creation", "kind": "variable", "doc": "

\n", "annotation": ": datetime.datetime"}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.action", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.action", "kind": "variable", "doc": "

\n", "annotation": ": Union[Literal['allow', 'deny', 'reset-client'], dict, NoneType]"}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.to_interface", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.to_interface", "kind": "variable", "doc": "

\n", "annotation": ": str"}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.protocol", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.protocol", "kind": "variable", "doc": "

\n", "annotation": ": Optional[Literal['tcp', 'udp']]"}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.port", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.port", "kind": "variable", "doc": "

\n", "annotation": ": Optional[str]"}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.to_", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.to_", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.from_", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.from_", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.source", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.source", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.destination", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.destination", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.source_translation", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.source_translation", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.destination_translation", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.destination_translation", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.source_user", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.source_user", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.application", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.application", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.category", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.category", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.service", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.service", "kind": "variable", "doc": "

\n", "annotation": ": Optional[List[str]]"}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.icmp_unreachable", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.log_start", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.log_start", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.log_end", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.log_end", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.negate_source", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.negate_source", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.negate_destination", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.negate_destination", "kind": "variable", "doc": "

\n", "annotation": ": Optional[bool]"}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.ensure_membership", "kind": "function", "doc": "

\n", "signature": "(cls, v: Any):", "funcdef": "def"}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.model_fields", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{'name': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@name', 'name'])), 'description': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'uuid': FieldInfo(annotation=str, required=True, alias_priority=2, validation_alias=AliasChoices(choices=['@uuid', 'uuid'])), 'state': FieldInfo(annotation=Union[str, NoneType], required=True, alias='rule-state', alias_priority=2), 'bytes': FieldInfo(annotation=Union[int, NoneType], required=False, default=None), 'group_tag': FieldInfo(annotation=Union[str, NoneType], required=False, default=None, alias='group-tag', alias_priority=2), 'tag': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'disabled': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None), 'rule_type': FieldInfo(annotation=Union[Literal['interzone', 'universal'], NoneType], required=False, default=None, alias='rule-type', alias_priority=2), 'nat_type': FieldInfo(annotation=Union[Literal['ipv4', 'ipv6'], NoneType], required=False, default=None, alias='nat-type', alias_priority=2), 'modification': FieldInfo(annotation=datetime, required=True, alias='rule-modification-timestamp', alias_priority=2), 'creation': FieldInfo(annotation=datetime, required=True, alias='rule-creation-timestamp', alias_priority=2), 'action': FieldInfo(annotation=Union[Literal['allow', 'deny', 'reset-client'], dict, NoneType], required=False, default=None), 'to_interface': FieldInfo(annotation=str, required=False, default=None, alias='to-interface', alias_priority=2), 'protocol': FieldInfo(annotation=Union[Literal['tcp', 'udp'], NoneType], required=False, default=None), 'port': FieldInfo(annotation=Union[str, NoneType], required=False, default=None), 'to_': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='from', alias_priority=2), 'from_': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='to', alias_priority=2), 'source': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'destination': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'source_translation': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='source-translation', alias_priority=2), 'destination_translation': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='destination-translation', alias_priority=2), 'source_user': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None, alias='source-user', alias_priority=2), 'application': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'category': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'service': FieldInfo(annotation=Union[List[str], NoneType], required=False, default=None), 'icmp_unreachable': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='icmp-unreachable', alias_priority=2), 'log_start': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='log-start', alias_priority=2), 'log_end': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='log-end', alias_priority=2), 'negate_source': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='negate-source', alias_priority=2), 'negate_destination': FieldInfo(annotation=Union[bool, NoneType], required=False, default=None, alias='negate-destination', alias_priority=2)}"}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"fullname": "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields", "modulename": "pa_api.xmlapi.types.statistics", "qualname": "RuleUse.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.utils": {"fullname": "pa_api.xmlapi.types.utils", "modulename": "pa_api.xmlapi.types.utils", "kind": "module", "doc": "

\n"}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"fullname": "pa_api.xmlapi.types.utils.DATETIME_FORMAT", "modulename": "pa_api.xmlapi.types.utils", "qualname": "DATETIME_FORMAT", "kind": "variable", "doc": "

\n", "default_value": "'%Y/%m/%d %H:%M:%S'"}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"fullname": "pa_api.xmlapi.types.utils.TIME_FORMAT", "modulename": "pa_api.xmlapi.types.utils", "qualname": "TIME_FORMAT", "kind": "variable", "doc": "

\n", "default_value": "'%H:%M:%S'"}, "pa_api.xmlapi.types.utils.NoneType": {"fullname": "pa_api.xmlapi.types.utils.NoneType", "modulename": "pa_api.xmlapi.types.utils", "qualname": "NoneType", "kind": "class", "doc": "

\n"}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"fullname": "pa_api.xmlapi.types.utils.XMLBaseModel", "modulename": "pa_api.xmlapi.types.utils", "qualname": "XMLBaseModel", "kind": "class", "doc": "

Usage docs: https://docs.pydantic.dev/2.8/concepts/models/

\n\n

A base class for creating Pydantic models.

\n\n

Attributes:\n __class_vars__: The names of classvars defined on the model.\n __private_attributes__: Metadata about the private attributes of the model.\n __signature__: The signature for instantiating the model.

\n\n
__pydantic_complete__: Whether model building is completed, or if there are still undefined fields.\n__pydantic_core_schema__: The pydantic-core schema used to build the SchemaValidator and SchemaSerializer.\n__pydantic_custom_init__: Whether the model has a custom `__init__` function.\n__pydantic_decorators__: Metadata containing the decorators defined on the model.\n    This replaces `Model.__validators__` and `Model.__root_validators__` from Pydantic V1.\n__pydantic_generic_metadata__: Metadata for generic models; contains data used for a similar purpose to\n    __args__, __origin__, __parameters__ in typing-module generics. May eventually be replaced by these.\n__pydantic_parent_namespace__: Parent namespace of the model, used for automatic rebuilding of models.\n__pydantic_post_init__: The name of the post-init method for the model, if defined.\n__pydantic_root_model__: Whether the model is a `RootModel`.\n__pydantic_serializer__: The pydantic-core SchemaSerializer used to dump instances of the model.\n__pydantic_validator__: The pydantic-core SchemaValidator used to validate instances of the model.\n\n__pydantic_extra__: An instance attribute with the values of extra fields from validation when\n    `model_config['extra'] == 'allow'`.\n__pydantic_fields_set__: An instance attribute with the names of fields explicitly set.\n__pydantic_private__: Instance attribute with the values of private attributes set on the model instance.\n
\n", "bases": "pydantic.main.BaseModel"}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"fullname": "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml", "modulename": "pa_api.xmlapi.types.utils", "qualname": "XMLBaseModel.from_xml", "kind": "function", "doc": "

\n", "signature": "(cls, xml) -> typing_extensions.Self:", "funcdef": "def"}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"fullname": "pa_api.xmlapi.types.utils.XMLBaseModel.model_config", "modulename": "pa_api.xmlapi.types.utils", "qualname": "XMLBaseModel.model_config", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"fullname": "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields", "modulename": "pa_api.xmlapi.types.utils", "qualname": "XMLBaseModel.model_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"fullname": "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields", "modulename": "pa_api.xmlapi.types.utils", "qualname": "XMLBaseModel.model_computed_fields", "kind": "variable", "doc": "

\n", "default_value": "{}"}, "pa_api.xmlapi.types.utils.parse_datetime": {"fullname": "pa_api.xmlapi.types.utils.parse_datetime", "modulename": "pa_api.xmlapi.types.utils", "qualname": "parse_datetime", "kind": "function", "doc": "

\n", "signature": "(d):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.parse_time": {"fullname": "pa_api.xmlapi.types.utils.parse_time", "modulename": "pa_api.xmlapi.types.utils", "qualname": "parse_time", "kind": "function", "doc": "

\n", "signature": "(d):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.Datetime": {"fullname": "pa_api.xmlapi.types.utils.Datetime", "modulename": "pa_api.xmlapi.types.utils", "qualname": "Datetime", "kind": "variable", "doc": "

\n", "default_value": "typing.Annotated[datetime.datetime, PlainValidator(func=<function parse_datetime>)]"}, "pa_api.xmlapi.types.utils.single_xpath": {"fullname": "pa_api.xmlapi.types.utils.single_xpath", "modulename": "pa_api.xmlapi.types.utils", "qualname": "single_xpath", "kind": "function", "doc": "

\n", "signature": "(xml, xpath, parser=None, default=None):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.pd": {"fullname": "pa_api.xmlapi.types.utils.pd", "modulename": "pa_api.xmlapi.types.utils", "qualname": "pd", "kind": "function", "doc": "

\n", "signature": "(d):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.sx": {"fullname": "pa_api.xmlapi.types.utils.sx", "modulename": "pa_api.xmlapi.types.utils", "qualname": "sx", "kind": "function", "doc": "

\n", "signature": "(xml, xpath, parser=None, default=None):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.mksx": {"fullname": "pa_api.xmlapi.types.utils.mksx", "modulename": "pa_api.xmlapi.types.utils", "qualname": "mksx", "kind": "function", "doc": "

\n", "signature": "(xml):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.ensure_list": {"fullname": "pa_api.xmlapi.types.utils.ensure_list", "modulename": "pa_api.xmlapi.types.utils", "qualname": "ensure_list", "kind": "function", "doc": "

\n", "signature": "(v: Any) -> List[Any]:", "funcdef": "def"}, "pa_api.xmlapi.types.utils.List": {"fullname": "pa_api.xmlapi.types.utils.List", "modulename": "pa_api.xmlapi.types.utils", "qualname": "List", "kind": "variable", "doc": "

\n", "default_value": "typing.Annotated[typing.List[~Element], BeforeValidator(func=<function ensure_list>)]"}, "pa_api.xmlapi.types.utils.ensure_str": {"fullname": "pa_api.xmlapi.types.utils.ensure_str", "modulename": "pa_api.xmlapi.types.utils", "qualname": "ensure_str", "kind": "function", "doc": "

\n", "signature": "(v: Any) -> str:", "funcdef": "def"}, "pa_api.xmlapi.types.utils.validate_ip": {"fullname": "pa_api.xmlapi.types.utils.validate_ip", "modulename": "pa_api.xmlapi.types.utils", "qualname": "validate_ip", "kind": "function", "doc": "

\n", "signature": "(v: Any) -> str:", "funcdef": "def"}, "pa_api.xmlapi.types.utils.String": {"fullname": "pa_api.xmlapi.types.utils.String", "modulename": "pa_api.xmlapi.types.utils", "qualname": "String", "kind": "variable", "doc": "

\n", "default_value": "typing.Annotated[str, BeforeValidator(func=<function ensure_str>)]"}, "pa_api.xmlapi.types.utils.Ip": {"fullname": "pa_api.xmlapi.types.utils.Ip", "modulename": "pa_api.xmlapi.types.utils", "qualname": "Ip", "kind": "variable", "doc": "

\n", "default_value": "typing.Annotated[str, BeforeValidator(func=<function validate_ip>)]"}, "pa_api.xmlapi.types.utils.xml2schema": {"fullname": "pa_api.xmlapi.types.utils.xml2schema", "modulename": "pa_api.xmlapi.types.utils", "qualname": "xml2schema", "kind": "function", "doc": "

Similar to schematype function:\nThe result is a recursive schema that can be dumped with json.

\n", "signature": "(xml):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.schematype": {"fullname": "pa_api.xmlapi.types.utils.schematype", "modulename": "pa_api.xmlapi.types.utils", "qualname": "schematype", "kind": "function", "doc": "

Recursively parse the data to infer the schema.\nThe schema is returned as a type.

\n\n

We can dump the json schema using pydantic:\nTypeAdapter(schematype({\"test\": 5})).json_schema()

\n", "signature": "(data, name: Optional[str] = None):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.xml2schematype": {"fullname": "pa_api.xmlapi.types.utils.xml2schematype", "modulename": "pa_api.xmlapi.types.utils", "qualname": "xml2schematype", "kind": "function", "doc": "

Same to schematype function but takes an xml Element as parameter

\n", "signature": "(xml):", "funcdef": "def"}, "pa_api.xmlapi.types.utils.jsonschema": {"fullname": "pa_api.xmlapi.types.utils.jsonschema", "modulename": "pa_api.xmlapi.types.utils", "qualname": "jsonschema", "kind": "function", "doc": "

\n", "signature": "(data, name=None, indent=4) -> str:", "funcdef": "def"}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"fullname": "pa_api.xmlapi.types.utils.xml2jsonschema", "modulename": "pa_api.xmlapi.types.utils", "qualname": "xml2jsonschema", "kind": "function", "doc": "

\n", "signature": "(data, indent=4) -> str:", "funcdef": "def"}}, "docInfo": {"pa_api": {"qualname": 0, "fullname": 2, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.panorama": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.panorama.Panorama": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 68}, "pa_api.panorama.Panorama.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 73, "bases": 0, "doc": 4}, "pa_api.restapi": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 95}, "pa_api.restapi.PanoramaClient.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.objects": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.policies": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.network": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.device": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.panorama": {"qualname": 2, "fullname": 5, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.PanoramaClient.client": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 10}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 10}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 10}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 1, "doc": 10}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient": {"qualname": 1, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 95}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"qualname": 3, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 55, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.objects": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.policies": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.network": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.device": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"qualname": 2, "fullname": 6, "annotation": 7, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.restapi.restapi.PanoramaClient.client": {"qualname": 2, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi": {"qualname": 0, "fullname": 3, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi": {"qualname": 1, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.__init__": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 71, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.logger": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.export_configuration": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 54, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.export_device_state": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 54, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.generate_apikey": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 12}, "pa_api.xmlapi.XMLApi.api_version": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.configuration": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 72, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.operation": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 52, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.ispanorama": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.get_tree": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 41, "bases": 0, "doc": 16}, "pa_api.xmlapi.XMLApi.get_rule_use": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 45, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 32, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.get": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 37}, "pa_api.xmlapi.XMLApi.delete": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 18}, "pa_api.xmlapi.XMLApi.create": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 21}, "pa_api.xmlapi.XMLApi.update": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 27, "bases": 0, "doc": 36}, "pa_api.xmlapi.XMLApi.revert_changes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 29, "bases": 0, "doc": 45}, "pa_api.xmlapi.XMLApi.validate_changes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 8}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 14}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 14}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 8}, "pa_api.xmlapi.XMLApi.pending_changes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "pa_api.xmlapi.XMLApi.save_config": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 10}, "pa_api.xmlapi.XMLApi.save_device_state": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 13}, "pa_api.xmlapi.XMLApi.candidate_config": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 12}, "pa_api.xmlapi.XMLApi.running_config": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 11}, "pa_api.xmlapi.XMLApi.get_jobs": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 88, "bases": 0, "doc": 27}, "pa_api.xmlapi.XMLApi.get_job": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 27}, "pa_api.xmlapi.XMLApi.get_versions": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 6}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 61, "bases": 0, "doc": 40}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 13}, "pa_api.xmlapi.XMLApi.commit_changes": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 28, "bases": 0, "doc": 5}, "pa_api.xmlapi.XMLApi.add_config_lock": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 49, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 39, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.set_ha_status": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 51, "bases": 0, "doc": 10}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 17}, "pa_api.xmlapi.XMLApi.get_ha_info": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 64, "bases": 0, "doc": 15}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 138, "bases": 0, "doc": 36}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 44}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 10}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "pa_api.xmlapi.XMLApi.get_devices": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 36}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 60}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 33, "bases": 0, "doc": 47}, "pa_api.xmlapi.XMLApi.get_addresses": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 25}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 53, "bases": 0, "doc": 25}, "pa_api.xmlapi.XMLApi.get_interfaces": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 25}, "pa_api.xmlapi.XMLApi.get_zones": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 31, "bases": 0, "doc": 25}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"qualname": 5, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 67}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 20}, "pa_api.xmlapi.XMLApi.system_info": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 12}, "pa_api.xmlapi.XMLApi.system_resources": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 22}, "pa_api.xmlapi.XMLApi.download_software": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 33}, "pa_api.xmlapi.XMLApi.install_software": {"qualname": 3, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 76, "bases": 0, "doc": 33}, "pa_api.xmlapi.XMLApi.restart": {"qualname": 2, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 5}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 65, "bases": 0, "doc": 49}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"qualname": 4, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 72, "bases": 0, "doc": 84}, "pa_api.xmlapi.types": {"qualname": 0, "fullname": 4, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.IPNetwork": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.get_ip_network": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 12, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.address.Address.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.type": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.prefix": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"qualname": 3, "fullname": 9, "annotation": 6, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 63, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 20, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 168, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.address.find_addresses": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 14}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"qualname": 3, "fullname": 9, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"qualname": 3, "fullname": 9, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 206, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 12, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"qualname": 4, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"qualname": 3, "fullname": 9, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 185, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 129, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"qualname": 4, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 211, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 187, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"qualname": 3, "fullname": 9, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"qualname": 2, "fullname": 8, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"qualname": 2, "fullname": 8, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 289, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"qualname": 2, "fullname": 8, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"qualname": 2, "fullname": 8, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"qualname": 4, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 250, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"qualname": 4, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 185, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"qualname": 2, "fullname": 8, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 58, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 145, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"qualname": 3, "fullname": 9, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"qualname": 2, "fullname": 8, "annotation": 18, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 83, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 214, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table": {"qualname": 0, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"qualname": 1, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"qualname": 3, "fullname": 11, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 25, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"qualname": 4, "fullname": 12, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"qualname": 1, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"qualname": 2, "fullname": 10, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"qualname": 2, "fullname": 10, "annotation": 10, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"qualname": 2, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"qualname": 2, "fullname": 10, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 95, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"qualname": 4, "fullname": 12, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"qualname": 1, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"qualname": 3, "fullname": 11, "annotation": 20, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 37, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"qualname": 4, "fullname": 12, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"qualname": 1, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"qualname": 2, "fullname": 10, "annotation": 10, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"qualname": 3, "fullname": 11, "annotation": 0, "default_value": 19, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"qualname": 4, "fullname": 12, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"qualname": 3, "fullname": 10, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"qualname": 2, "fullname": 9, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"qualname": 2, "fullname": 9, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 91, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"qualname": 3, "fullname": 10, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 33, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"qualname": 3, "fullname": 10, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 30, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"qualname": 5, "fullname": 12, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"qualname": 3, "fullname": 10, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"qualname": 3, "fullname": 10, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"qualname": 2, "fullname": 9, "annotation": 25, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"qualname": 2, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 72, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"qualname": 3, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 61, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"qualname": 2, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"qualname": 3, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"qualname": 3, "fullname": 10, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"qualname": 3, "fullname": 10, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"qualname": 3, "fullname": 10, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"qualname": 4, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"qualname": 4, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"qualname": 2, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 334, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"qualname": 2, "fullname": 9, "annotation": 19, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"qualname": 2, "fullname": 9, "annotation": 19, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 80, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security": {"qualname": 0, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 39, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Option": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"qualname": 5, "fullname": 12, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 28, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Target": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"qualname": 2, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 14, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security": {"qualname": 1, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"qualname": 2, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"qualname": 3, "fullname": 10, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"qualname": 3, "fullname": 10, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"qualname": 2, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"qualname": 2, "fullname": 9, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"qualname": 3, "fullname": 10, "annotation": 12, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"qualname": 3, "fullname": 10, "annotation": 19, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"qualname": 2, "fullname": 9, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"qualname": 2, "fullname": 9, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"qualname": 3, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"qualname": 3, "fullname": 10, "annotation": 0, "default_value": 690, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"qualname": 4, "fullname": 11, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"qualname": 2, "fullname": 8, "annotation": 22, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"qualname": 5, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 101, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.name": {"qualname": 2, "fullname": 8, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.network": {"qualname": 2, "fullname": 8, "annotation": 8, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 105, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 16, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.serial": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.connected": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.family": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.model": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"qualname": 6, "fullname": 12, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"qualname": 5, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"qualname": 3, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"qualname": 3, "fullname": 9, "annotation": 13, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"qualname": 5, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"qualname": 5, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"qualname": 5, "fullname": 11, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 887, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 16, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 112, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 6, "doc": 277}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 16, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"qualname": 3, "fullname": 9, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 16, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 205, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"qualname": 4, "fullname": 10, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.parse_progress": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.JobResult": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 2, "doc": 5}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"qualname": 2, "fullname": 8, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 186, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"qualname": 2, "fullname": 8, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"qualname": 2, "fullname": 8, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.id": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.user": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.type": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.status": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.queued": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.result": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"qualname": 2, "fullname": 8, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.description": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.progress": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.details": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 46, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software": {"qualname": 0, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"qualname": 1, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 87, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"qualname": 3, "fullname": 9, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"qualname": 2, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"qualname": 3, "fullname": 9, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"qualname": 4, "fullname": 10, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 277}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"qualname": 2, "fullname": 7, "annotation": 11, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"qualname": 2, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"qualname": 2, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 157, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 277}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 9, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"qualname": 3, "fullname": 8, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"qualname": 3, "fullname": 8, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"qualname": 2, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"qualname": 2, "fullname": 7, "annotation": 3, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"qualname": 2, "fullname": 7, "annotation": 15, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"qualname": 2, "fullname": 7, "annotation": 9, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"qualname": 2, "fullname": 7, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"qualname": 3, "fullname": 8, "annotation": 2, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 21, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 570, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils": {"qualname": 0, "fullname": 5, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 6, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 5, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.NoneType": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 0, "bases": 3, "doc": 277}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"qualname": 3, "fullname": 8, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"qualname": 4, "fullname": 9, "annotation": 0, "default_value": 1, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.parse_datetime": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.parse_time": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.Datetime": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.single_xpath": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.pd": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.sx": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 36, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.mksx": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.ensure_list": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 25, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.List": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 11, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.ensure_str": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.validate_ip": {"qualname": 2, "fullname": 7, "annotation": 0, "default_value": 0, "signature": 19, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.String": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 10, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.Ip": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 10, "signature": 0, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.xml2schema": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 19}, "pa_api.xmlapi.types.utils.schematype": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 37}, "pa_api.xmlapi.types.utils.xml2schematype": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 11, "bases": 0, "doc": 13}, "pa_api.xmlapi.types.utils.jsonschema": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 34, "bases": 0, "doc": 3}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"qualname": 1, "fullname": 6, "annotation": 0, "default_value": 0, "signature": 24, "bases": 0, "doc": 3}}, "length": 697, "save": true}, "index": {"qualname": {"root": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}}, "df": 15, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}}, "df": 7, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}}, "df": 16}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}}, "df": 37}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}}, "df": 35}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}}, "df": 33}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}}, "df": 4}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}}, "df": 1}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}}, "df": 5}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}}, "df": 2}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"pa_api.xmlapi.types.utils.pd": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 11}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}}, "df": 17, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}}, "df": 8}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 24, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}}, "df": 1}}}}}}}, "v": {"4": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "6": {"docs": {"pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}}, "df": 3}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "f": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}}, "df": 2}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}}, "df": 6}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}}, "df": 1}, "n": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 7}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}}, "df": 6}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 5}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 22, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}}, "df": 20, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.NoneType": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}}, "df": 52, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}}, "df": 12, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.delete": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}}, "df": 11}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}}, "df": 6}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}}, "df": 2}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}}, "df": 4}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}}, "df": 1}}}}}}}}}, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}}, "df": 2, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}}, "df": 1}}, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}}, "df": 39, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 3}}}}}}}}}}, "n": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}}, "df": 3}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 34}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}}, "df": 7}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}}, "df": 6}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 4}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}}, "df": 5, "s": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.restart": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}}, "df": 4, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}}, "df": 9, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}}, "df": 14}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}}, "df": 36}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.running_config": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}}, "df": 1}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 13}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}}, "df": 13, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}}, "df": 4, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}}, "df": 13}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}}, "df": 6}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}}, "df": 8}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}}, "df": 5}}}}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}}, "df": 1}}}, "o": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}}, "df": 4}, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}}, "df": 2}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}}, "df": 13, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.api_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 20, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}}, "df": 5}}}}}}}, "p": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}}, "df": 2, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}}, "df": 14}}}}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}}, "df": 18, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}}, "df": 3, "d": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}}, "df": 4}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}}, "df": 15, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}}, "df": 2, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}}, "df": 25, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}}, "df": 2}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "i": {"docs": {"pa_api.xmlapi.XMLApi.api_version": {"tf": 1}}, "df": 1, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}}, "df": 2}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}}, "df": 12, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.logger": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4}, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}}, "df": 6}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}}, "df": 12}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}}, "df": 16}, "docs": {}, "df": 0}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}}, "df": 3}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}}, "df": 30, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}}, "df": 9}, "u": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}}, "df": 7}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}}, "df": 8}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}}, "df": 5}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {"pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.utils.String": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}}, "df": 3, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 4, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 12}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}}, "df": 10}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}}, "df": 1}}, "w": {"docs": {"pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {"pa_api.xmlapi.types.utils.sx": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}}, "df": 8, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 2}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}}, "df": 7}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}}, "df": 6, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}}, "df": 16}}}}}}}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}}, "df": 27}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1, "d": {"docs": {"pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}}, "df": 4, "l": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 103}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}}, "df": 2}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {"pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}}, "df": 3}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 2}}}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.utils.mksx": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}}, "df": 1, "r": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}}, "df": 5}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}}, "df": 3}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 68}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}}}}}}, "q": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 8}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}}, "df": 2}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}}, "df": 1}}}}}}}}, "x": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"2": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 1}}}}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 1}}}}}}}}}}}, "docs": {"pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.XMLApi": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.logger": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 62}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"1": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}}, "df": 4}, "2": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}}, "df": 2}, "docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}}, "df": 21}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}}, "df": 1}}}}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 20, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}}, "df": 3}}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}}, "df": 1}}}}}}}, "fullname": {"root": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}}, "df": 15, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api": {"tf": 1}, "pa_api.panorama": {"tf": 1}, "pa_api.panorama.Panorama": {"tf": 1}, "pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.rest_resources": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}, "pa_api.restapi.restapi": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.xmlapi": {"tf": 1}, "pa_api.xmlapi.XMLApi": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.logger": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types": {"tf": 1}, "pa_api.xmlapi.types.config": {"tf": 1}, "pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 697, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.panorama": {"tf": 1}, "pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.panorama.Panorama.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}}, "df": 8, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}}, "df": 16}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}}, "df": 37}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}}, "df": 35}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}}, "df": 4}}}}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}}, "df": 33}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}}, "df": 4}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 2}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 2}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}}, "df": 3}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 3}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 2}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}}, "df": 4, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}}, "df": 1}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}}, "df": 5}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}}, "df": 2}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}}, "df": 2}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}, "d": {"docs": {"pa_api.xmlapi.types.utils.pd": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api": {"tf": 1}, "pa_api.panorama": {"tf": 1}, "pa_api.panorama.Panorama": {"tf": 1}, "pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.rest_resources": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}, "pa_api.restapi.restapi": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.xmlapi": {"tf": 1}, "pa_api.xmlapi.XMLApi": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.logger": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types": {"tf": 1}, "pa_api.xmlapi.types.config": {"tf": 1}, "pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 697, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}}, "df": 2}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}}, "df": 15, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}}, "df": 2, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}}, "df": 29, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}}, "df": 4}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}}, "df": 2}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 1}, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 11}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}}, "df": 120, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}}, "df": 8}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}}, "df": 2}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 24, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}}, "df": 1}}}}}}}, "v": {"4": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}}}, "6": {"docs": {"pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}}, "df": 3}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}}, "df": 2}}}, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "f": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.rest_resources": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}}, "df": 115, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.restapi": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.rest_resources": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}, "pa_api.restapi.restapi": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1.4142135623730951}}, "df": 133}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.restart": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}}, "df": 5, "s": {"docs": {"pa_api.restapi.rest_resources": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 116}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1}}, "df": 1}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}}, "df": 4, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}}, "df": 10, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}}, "df": 107}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}}, "df": 14}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}}, "df": 36}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.running_config": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}}, "df": 2}, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1.4142135623730951}}, "df": 26, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.types.operations": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 120}, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}}, "df": 6}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}}, "df": 1}, "n": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}}, "df": 1}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 7}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}}, "df": 6}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 5}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 56, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}}, "df": 20, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.NoneType": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}}, "df": 88, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1.4142135623730951}}, "df": 13, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 3}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}}, "df": 2}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}}}, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.delete": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}}, "df": 11}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 6, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}}, "df": 6}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}}, "df": 2}}}}}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}}, "df": 1}}}}}}, "h": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1}}, "df": 1}}}}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}}, "df": 4}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1}}, "df": 1}}}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}}, "df": 1}}}}}}}}}, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}}, "df": 2}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}}, "df": 5, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}}, "df": 7}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}}, "df": 2, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}}, "df": 1}}, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}}, "df": 1}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "v": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.types.config": {"tf": 1}, "pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}}, "df": 309, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 3}}}}}}}}}}, "n": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}}, "df": 3}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 34}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 3}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}}, "df": 7}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}}, "df": 2}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}}, "df": 6}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 4}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 13, "s": {"docs": {"pa_api.xmlapi.types": {"tf": 1}, "pa_api.xmlapi.types.config": {"tf": 1}, "pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 497}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}}, "df": 13, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}}, "df": 4, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}}, "df": 13}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}}, "df": 24, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}}, "df": 6}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}}, "df": 1}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}}, "df": 8}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}}, "df": 5}}}}}}}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}}, "df": 1}}}, "o": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}}, "df": 4}, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}}, "df": 2}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}}, "df": 2, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}}, "df": 2}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1}}, "df": 1}}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}}, "df": 13, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.api_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 20, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}}, "df": 5}}}}}}}, "p": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}}, "df": 2, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}}, "df": 1}}}}}}, "f": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}}, "df": 14}}}}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}}, "df": 18, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}}, "df": 2}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}}, "df": 3, "d": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}}, "df": 4}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}}, "df": 12, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}}, "df": 5, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.logger": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4}, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}}, "df": 2, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}}, "df": 6}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}}, "df": 12}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}}, "df": 16}, "docs": {}, "df": 0}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 2}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1}}, "df": 1}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}}, "df": 3}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1.4142135623730951}}, "df": 46, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1}}, "df": 1}}}}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}}, "df": 2}}}}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1}}, "df": 1}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}}, "df": 9}, "u": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}}, "df": 7}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}}, "df": 8}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}}, "df": 5}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.statistics": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}}, "df": 51}}}}}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {"pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.utils.String": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 1}}}}}, "b": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}}, "df": 3, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 17, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 12}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}}, "df": 7, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}}, "df": 10}}}}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}}, "df": 2}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}}, "df": 1}}, "w": {"docs": {"pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}}, "df": 1}}}}}, "x": {"docs": {"pa_api.xmlapi.types.utils.sx": {"tf": 1}}, "df": 1}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1.4142135623730951}}, "df": 16, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 2}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}}, "df": 7}}}}}}}}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}}, "df": 6, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}}, "df": 1, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1}}, "df": 1}}}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "m": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1}}, "df": 1}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}}, "df": 16}}}}}}}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}}, "df": 27}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1}}, "df": 1}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1}}, "df": 1}}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 1, "d": {"docs": {"pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}}, "df": 4, "l": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 103}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}}, "df": 2}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {"pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}}, "df": 3}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}}, "df": 2}}}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}}, "df": 1}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}}, "df": 1}}}}}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.utils.mksx": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}}, "df": 1, "r": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}}, "df": 5}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}}, "df": 2}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}}, "df": 3}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.utils": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 27}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 68}}}}, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}}, "df": 1}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}}}}}}, "q": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 8}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}}, "df": 2}}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}}, "df": 3, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}}, "df": 1}}}}}}}}, "x": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"2": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 1}}}}}}}}}}, "j": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 1}}}}}}}}}}}, "docs": {"pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 4, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi": {"tf": 1}, "pa_api.xmlapi.XMLApi": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.logger": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.create": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.update": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types": {"tf": 1}, "pa_api.xmlapi.types.config": {"tf": 1}, "pa_api.xmlapi.types.config.address": {"tf": 1}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations": {"tf": 1}, "pa_api.xmlapi.types.operations.device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 560}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}}, "df": 5}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}}, "df": 1}}}}}, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 1}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}}}}, "a": {"1": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}}, "df": 4}, "2": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}}, "df": 2}, "docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}}, "df": 6, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}}, "df": 21}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}}, "df": 1}}}}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.operations.job": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1.4142135623730951}}, "df": 26, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}}, "df": 3}}}}}}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}}, "df": 1}}}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}}, "df": 2}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}}, "df": 1}}}}}}}, "annotation": {"root": {"0": {"docs": {}, "df": 0, "x": {"7": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"4": {"8": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"2": {"docs": {}, "df": 0, "b": {"6": {"4": {"0": {"docs": {"pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}}, "df": 51}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "d": {"0": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}}, "df": 70}, "docs": {}, "df": 0}}, "7": {"6": {"0": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "e": {"6": {"2": {"2": {"0": {"0": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}}, "docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 301, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.4142135623730951}}, "df": 12, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}}, "df": 1}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 42}}, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 94}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}}, "df": 32}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}}, "df": 15}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}}, "df": 4}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}}, "df": 24}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}}, "df": 10, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}}, "df": 10}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1}}, "df": 10}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}}, "df": 13}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}}, "df": 7}}}}}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 32}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1}}, "df": 108}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}}, "df": 2}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}}, "df": 4}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1}}, "df": 62}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}}, "df": 17}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 15}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1}}, "df": 4}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1}}, "df": 20}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1}}, "df": 11}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}}, "df": 1}}}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}}, "df": 1}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 1}}}}}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}}, "df": 3, "v": {"4": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "6": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}}, "df": 1}}}}}}}}, "docs": {}, "df": 0}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1}}, "df": 3, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}}, "df": 14}}}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1.4142135623730951}}, "df": 7}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}}, "df": 92}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1}}, "df": 14}}}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 94, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 94}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 94}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1}}, "df": 51, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1}}, "df": 3}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}}, "df": 3}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}}, "df": 3}, "docs": {}, "df": 0}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}}, "df": 1}}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}}, "df": 92}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1}}, "df": 94}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1}}, "df": 24}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 32}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}}, "df": 3}}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1}}, "df": 1}}}, "x": {"2": {"7": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 2}}, "df": 6}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 32}}}}}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1}}, "df": 3}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1}}, "df": 2}}}}, "d": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}}, "df": 2, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1.4142135623730951}}, "df": 10}}}}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1}}, "df": 1}}}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "default_value": {"root": {"2": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.58257569495584}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.916079783099616}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 4.358898943540674}}, "df": 30}, "docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 4}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 4.47213595499958}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 3.7416573867739413}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 4.47213595499958}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 5}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 4.69041575982343}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 4.69041575982343}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 7.937253933193772}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 6.782329983125268}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 6.4031242374328485}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 124, "x": {"2": {"7": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 2}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 2}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 5.656854249492381}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 6}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 5.291502622129181}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 5.830951894845301}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 7.874007874011811}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 7.0710678118654755}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 6.324555320336759}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 5.291502622129181}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 6.782329983125268}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 4}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 7.0710678118654755}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 4}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 10.862780491200215}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 4.47213595499958}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 12.806248474865697}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 5.656854249492381}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 11.045361017187261}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1.4142135623730951}}, "df": 73}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}}, "df": 2}}}}}}, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 2, "d": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.47213595499958}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.List": {"tf": 1}}, "df": 20, "[": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}}, "df": 15}}}}}}}}}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}}, "df": 1}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}}, "df": 4}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}}, "df": 1}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "v": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}}, "df": 2}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1}}, "df": 1}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "~": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.List": {"tf": 1}}, "df": 1}}}}}}}}}}}, "n": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3}}, "df": 2}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 28}, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}}, "df": 3}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}}, "df": 4}, "docs": {}, "df": 0}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1}}, "df": 2}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 11}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 5}}}, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 4}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2.23606797749979}}, "df": 21}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 2}}, "df": 4}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 2}}}}}}}}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.7320508075688772}}, "df": 11, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 11}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}}, "df": 2}}}}}, "o": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 3}, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}}, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "c": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.69041575982343}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.656854249492381}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.0990195135927845}}, "df": 28}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 10}}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2.23606797749979}}, "df": 4, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 2}}}}}}}}}}, "n": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}}, "df": 2}}}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 2}}, "df": 1}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 2, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 3}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}}}}}}, "b": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}}, "df": 3}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2}}, "df": 1}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.7320508075688772}}, "df": 22}}, "t": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.477225575051661}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.0990195135927845}}, "df": 24, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.656854249492381}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.0990195135927845}}, "df": 24}}}}}}}}, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1}}}}, "k": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1.4142135623730951}}, "df": 1}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 19}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.Datetime": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}}, "df": 2}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 3}}, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}}, "df": 3}}}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.58257569495584}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.916079783099616}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 4.358898943540674}}, "df": 31}}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}}, "df": 2, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}}, "df": 1}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 3.1622776601683795}}, "df": 1}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.7320508075688772}}, "df": 2, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}}, "df": 1}}}}}}}, "v": {"4": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "docs": {}, "df": 0}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.477225575051661}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 10}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 14}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}}}}}}}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"2": {"docs": {"pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}}, "df": 2}, "3": {"docs": {"pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 3.3166247903554}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "d": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2.449489742783178}}, "df": 8}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}}}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}}, "df": 6}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.7320508075688772}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}, "d": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 15, "v": {"4": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "6": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}}, "df": 2}}}}}}}}, "docs": {}, "df": 0}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.7320508075688772}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}}, "df": 5}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 7}}}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}}, "df": 1}}}}}}}}}}}}}, "f": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 2}}, "df": 1}, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 5}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 6.48074069840786}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.5677643628300215}}, "df": 33}}}}}}}, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.69041575982343}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.656854249492381}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.0990195135927845}}, "df": 28}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}}, "df": 15}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1.4142135623730951}}, "df": 1}}}, "q": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}}, "df": 1}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 26, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 26}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 3}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 5}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 6.48074069840786}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.5677643628300215}}, "df": 33}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "[": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.Datetime": {"tf": 1}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.utils.List": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 2}}}}}}}}}}}, "d": {"docs": {"pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 4.795831523312719}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 4.123105625617661}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 3.872983346207417}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 4.69041575982343}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 6.48074069840786}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 8.366600265340756}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 6.164414002968976}}, "df": 30, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 3}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 19}}}}}}}, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 19}}}}, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 7, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}}, "df": 1}}}}}}}}, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}}, "df": 4}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}}}}}}}}}, "v": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.String": {"tf": 1}}, "df": 21}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 6}, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}, "u": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}}, "df": 3, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.7320508075688772}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2.6457513110645907}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 2}}}}}}, "w": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 3.4641016151377544}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 5}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 6.48074069840786}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 5.5677643628300215}}, "df": 33}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 2.23606797749979}}, "df": 3, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 2}}, "df": 2}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3.3166247903554}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.58257569495584}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.916079783099616}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 30}}}, "e": {"docs": {"pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 5.656854249492381}}, "df": 1}}}}}}, "p": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.7320508075688772}}, "df": 7}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}}, "df": 1}}}, "y": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 2}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2.8284271247461903}}, "df": 1}}}}}}}}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.6457513110645907}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 4}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 4.795831523312719}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 27}}}}}}}}}}}}}}, "u": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}}, "df": 3, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1}}, "df": 3}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1}}, "df": 11}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}}, "df": 22}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "c": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.7320508075688772}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {"pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 2, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}}}}}}}}}}, "n": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}, "g": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}}, "df": 24}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}}, "df": 11}}}, "d": {"docs": {"pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 2}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 2}}, "df": 2, "d": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1}}, "df": 1}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1}}, "df": 22}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.449489742783178}}, "df": 2}}}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 3}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 3.605551275463989}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.List": {"tf": 1}, "pa_api.xmlapi.types.utils.String": {"tf": 1}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1}}, "df": 28}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.4142135623730951}}, "df": 7, "s": {"docs": {"pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1}}, "df": 1}}}}, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 2.449489742783178}}, "df": 1}}}}}}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1}}, "df": 1}}}}}}}, "a": {"1": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 2}}, "df": 1}, "2": {"docs": {"pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.4142135623730951}}, "df": 1}, "docs": {"pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.4142135623730951}}, "df": 1}, ":": {"docs": {}, "df": 0, "%": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "%": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1}}, "df": 2}}}}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1}}, "df": 2}}}}}}}}}, "y": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "%": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "%": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1}}, "df": 1}}}}}}}}}, "signature": {"root": {"0": {"docs": {}, "df": 0, "x": {"7": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "f": {"4": {"8": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"2": {"docs": {}, "df": 0, "b": {"6": {"4": {"0": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "6": {"docs": {}, "df": 0, "e": {"6": {"7": {"0": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 6}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}}, "1": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}}, "df": 7}, "3": {"9": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 2}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1.4142135623730951}}, "df": 13}, "docs": {}, "df": 0}, "4": {"docs": {"pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 2}, "docs": {"pa_api.panorama.Panorama.__init__": {"tf": 7.681145747868608}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 6.48074069840786}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 4.69041575982343}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 4.69041575982343}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 4.69041575982343}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 4.69041575982343}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 4.69041575982343}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 6.48074069840786}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 7.615773105863909}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 6.557438524302}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 6.557438524302}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 7.483314773547883}, "pa_api.xmlapi.XMLApi.operation": {"tf": 6.324555320336759}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 5.656854249492381}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 6.082762530298219}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 5.0990195135927845}, "pa_api.xmlapi.XMLApi.get": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.delete": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.create": {"tf": 4.69041575982343}, "pa_api.xmlapi.XMLApi.update": {"tf": 4.69041575982343}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 3.7416573867739413}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 3.7416573867739413}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 8.426149773176359}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 6}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 6.082762530298219}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 6.928203230275509}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 6.164414002968976}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 5.477225575051661}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 6.164414002968976}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 5.477225575051661}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 6.557438524302}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 5.0990195135927845}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 7.14142842854285}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 10.44030650891055}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 4.123105625617661}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 6.855654600401044}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 5.0990195135927845}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 6.082762530298219}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 6.48074069840786}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 6.082762530298219}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 4.898979485566356}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 4.242640687119285}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 4.58257569495584}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 7.874007874011811}, "pa_api.xmlapi.XMLApi.restart": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 7.280109889280518}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 7.810249675906654}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 7}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 4}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 4}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 6.855654600401044}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 8}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 3.7416573867739413}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 12.288205727444508}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 6.082762530298219}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 8.426149773176359}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 4.242640687119285}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 4.47213595499958}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 5.477225575051661}, "pa_api.xmlapi.types.utils.pd": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.sx": {"tf": 5.477225575051661}, "pa_api.xmlapi.types.utils.mksx": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 4.58257569495584}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 4}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 4}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.schematype": {"tf": 5.385164807134504}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 5.291502622129181}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 4.47213595499958}}, "df": 107, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 25}}, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}}, "df": 1}}, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 2}}}, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1.4142135623730951}}, "df": 1}}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2}}}}}}}, "y": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}}, "df": 5}}}, "u": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 2}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.sx": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}}, "df": 34, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}}, "df": 5}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}}, "df": 2}}}}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 21, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 2}}}}}}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}}, "df": 7, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 1}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 2}}}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}}, "df": 4}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}}}}}, "d": {"docs": {"pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1}, "pa_api.xmlapi.types.utils.pd": {"tf": 1}}, "df": 4, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}}, "df": 7}}}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 2}}}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}}, "df": 2}}}}}, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "a": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 3}}}}, "v": {"1": {"0": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}}, "df": 7}, "docs": {}, "df": 0}, "docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}}, "df": 6, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 12}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}}, "df": 5}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4}}}}, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 13}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1}}, "df": 5}}}}, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 5}}, "y": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 6}}}}}}}}}, "m": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}}, "df": 2}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 4}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 11}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.XMLApi.__init__": {"tf": 1}}, "df": 1}}}}}}}}}, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 9}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 2}}}}}, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 3, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}}, "df": 1}}, "p": {"docs": {"pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1}}, "df": 2}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}}, "df": 7}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1}}, "df": 1, "i": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.__init__": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}}, "df": 3}}}}}}, "e": {"docs": {}, "df": 0, "x": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 2}}, "n": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}}, "df": 7}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1}}, "df": 3}}}, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 2}}}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 21}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 3}}}}}, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}}, "df": 3}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.4142135623730951}}, "df": 1}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "q": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.__init__": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1}}, "df": 10}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "f": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 70}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1}}, "df": 21}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}}, "df": 1}, "u": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 3, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 3}}}}}}}}}}}}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 6}}}}}}, "x": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}}, "df": 1}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}}, "df": 3}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}}, "df": 4}}}}}}}}, "n": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2}}}}}}, "g": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1.4142135623730951}}, "df": 1}, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 8}}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}}, "df": 7}}}}, "m": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1}, "pa_api.xmlapi.types.utils.sx": {"tf": 1}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 11, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 21}}}}}}, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 2}}}}}, "a": {"docs": {}, "df": 0, "x": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1}}}}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1.4142135623730951}}, "df": 1, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.XMLApi.configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 2}}, "df": 10}}}, "e": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 10}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1}}, "df": 10}}}}}}}}}, "n": {"docs": {"pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1}}, "df": 1, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}}, "df": 1}}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1.4142135623730951}}, "df": 4}}}, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1, "d": {"docs": {"pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "bases": {"root": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}}, "df": 1, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}}, "df": 5}}}}}}}}}}}}}}}}}}}, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 3}}}}}}}}, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31}}}, "x": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31}}}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}}, "df": 31}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1.4142135623730951}}, "df": 1}}}}, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 3}}}}, "b": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 3}}}}}}}}}}}, "doc": {"root": {"1": {"2": {"3": {"4": {"5": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}, "2": {"2": {"7": {"docs": {}, "df": 0, "c": {"2": {"docs": {}, "df": 0, "c": {"1": {"1": {"3": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"4": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}, "docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}}, "df": 1}, "3": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}, "4": {"1": {"8": {"8": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "5": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}, "6": {"1": {"5": {"4": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "8": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}}}}}}}}}}, "docs": {"pa_api": {"tf": 1.7320508075688772}, "pa_api.panorama": {"tf": 1.7320508075688772}, "pa_api.panorama.Panorama": {"tf": 5.477225575051661}, "pa_api.panorama.Panorama.__init__": {"tf": 1.4142135623730951}, "pa_api.restapi": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient": {"tf": 3.4641016151377544}, "pa_api.restapi.PanoramaClient.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.objects": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.policies": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.network": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.device": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.panorama": {"tf": 1.7320508075688772}, "pa_api.restapi.PanoramaClient.client": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.DEFAULT_PARAMS": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.resource_type": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType.VirtualSystems": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DEFAULT_PARAMS": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.resource_type": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.EthernetInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.AggregateEthernetInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LoopbackInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.TunnelIntefaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.Zones": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VLANs": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualWires": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.VirtualRouters": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IPSecTunnels": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GRETunnels": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPServers": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DHCPRelays": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.DNSProxies": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectPortals": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGateways": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayAgentTunnels": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewaySatelliteTunnels": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectGatewayMDMServers": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessApps": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectClientlessAppGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSInterfaces": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDP": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.GlobalProtectIPSecCryptoNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKEGatewayNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.IKECryptoNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.MonitorNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.InterfaceManagementNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.ZoneProtectionNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.QoSNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.LLDPNetworkProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType.SDWANInterfaceProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.resource_type": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Addresses": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AddressGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Regions": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Applications": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ApplicationFilters": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Services": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ServiceGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Tags": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPObjects": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.GlobalProtectHIPProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.ExternalDynamicLists": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomDataPatterns": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomSpywareSignatures": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomVulnerabilitySignatures": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.CustomURLCategories": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntivirusSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AntiSpywareSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.VulnerabilityProtectionSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.URLFilteringSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.FileBlockingSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.WildFireAnalysisSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DataFilteringSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DoSProtectionSecurityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SecurityProfileGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.LogForwardingProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.AuthenticationEnforcements": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.DecryptionForwardingProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.Schedules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANPathQualityProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType.SDWANTrafficDistributionProfiles": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.resource_type": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPanoramaResourceType.DeviceGroups": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.resource_type": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SecurityRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.NATRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.QoSRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.PolicyBasedForwardingRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DecryptionRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.TunnelInspectionRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverridePostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.ApplicationOverrideRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.AuthenticationRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.DoSRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPreRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANPostRules": {"tf": 1.7320508075688772}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType.SDWANRules": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 3.4641016151377544}, "pa_api.restapi.restapi.PanoramaClient.__init__": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.objects": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.policies": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.network": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.device": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.panorama": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient.client": {"tf": 1.7320508075688772}, "pa_api.xmlapi": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.__init__": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.logger": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.export_configuration": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.export_device_state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.api_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.configuration": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.operation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.ispanorama": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 2}, "pa_api.xmlapi.XMLApi.get_rule_use": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_rule_hit_count": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.create": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.update": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 3.7416573867739413}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 2.6457513110645907}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.add_config_lock": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.remove_config_lock": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.add_commit_lock": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.remove_commit_lock": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 3.1622776601683795}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.raw_get_local_panorama": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_local_panorama_ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 3.3166247903554}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 3.872983346207417}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 2.6457513110645907}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.IPNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.get_ip_network": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.address.Address.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.prefix": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.ip_netmask": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.ip_network": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.ip_range": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.fqdn": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.validate_tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.validate_ip_network": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.validate_type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.find_addresses": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.devices": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.addresses": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.post_rulebase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.pre_rulebase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.iter_rulebases": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.get_ip_network": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.parent": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.untagged_sub_interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_speed": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.link_duplex": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.aggregate_group": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Layer2.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.units": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Layer3.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.untagged_sub_interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.units": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Vlan.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.units": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Ethernet.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.link_state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.link_speed": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.link_duplex": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.aggregate_group": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.units": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.untagged_sub_interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Tunnel.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.units": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.interface_management_profile": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.mtu": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Loopback.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.inttype": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.comment": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.interface.Interface.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.aggregate_ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.flatten": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.ip_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.nexthop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.destination": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.static_routes": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip_and_port": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.dynamic_ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.static_ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.translated_port": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.nat.NAT.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.uuid": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.disabled": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.group_tag": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.services": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.source_translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.destination_translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.sources": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.destinations": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.to": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.from_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_src_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.translated_dst_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.members": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.nat": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.groups": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.security.Option.disable_server_response_inspection": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.security.Target.negate": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.rules.security.Security.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.uuid": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.disabled": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.action": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.to": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.from_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.sources": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.destinations": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.source_users": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.services": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.applications": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.categories": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.tags": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.group_tag": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.profile_settings": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.rule_type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.negate_source": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.negate_destination": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.log_settings": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.log_start": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.log_end": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.icmp_unreachable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.enable_packet_buffer_protection": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.config.zone.Zone.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.network": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.enable_user_identification": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.enable_device_identification": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.operations.device.Device.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.serial": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.connected": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.unsupported_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.wildfire_rt": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.deactivated": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.hostname": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.ip_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.ipv6_address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.mac_addr": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.uptime": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.family": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.sw_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.app_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.av_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.device_dictionary_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.wildfire_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.threat_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.url_db": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.url_filtering_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.logdb_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.vpnclient_package_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.global_protect_client_package_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.prev_app_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.prev_av_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.prev_threat_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.prev_wildfire_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.prev_device_dictionary_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.ha_peer_serial": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.vpn_disable_mode": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.operational_mode": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.certificate_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.certificate_subject_name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.certificate_expiry": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.connected_at": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.custom_certificate_usage": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.multi_vsys": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.last_masterkey_push_timestamp": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.express_mode": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.device_cert_present": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.device_cert_expiry_date": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.id": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.gwid": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.inner_if": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.outer_if": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.localip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.peerip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.mon": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.owner": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.operations.device.HAInfo.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.enabled": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.preemptive": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.mode": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.priority": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_priority": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.is_primary": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.peer_conn_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.mgmt_ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_ipaddr": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_ipaddr": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_ipaddr": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_macaddress": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha1_backup_macaddress": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.ha2_macaddress": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.from_xml": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.parse_tdeq": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.parse_progress": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.JobResult.OK": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.JobResult.FAIL": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.__init__": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.tenq": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.tdeq": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.id": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.user": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.queued": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.stoppable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.result": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.tfin": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.position_in_queue": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.progress": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.details": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.warnings": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.job.Job.from_xml": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.__init__": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.filename": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.released_on": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.downloaded": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.current": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.latest": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.uploaded": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.from_xml": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_minor_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.software.SoftwareVersion.base_major_version": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.statistics.RuleHit.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.device_group": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.rulebase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.modification": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.creation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.all_connected": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.ensure_datetime": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.from_tuple": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.statistics.RuleUse.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.name": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.description": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.uuid": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.state": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.bytes": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.group_tag": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.tag": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.disabled": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.rule_type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.nat_type": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.modification": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.creation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.action": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.to_interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.protocol": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.port": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.to_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.from_": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.source": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.destination": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.source_translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.destination_translation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.source_user": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.application": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.category": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.service": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.icmp_unreachable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.log_start": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.log_end": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.negate_source": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.negate_destination": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.ensure_membership": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.DATETIME_FORMAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.TIME_FORMAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.NoneType": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 6.164414002968976}, "pa_api.xmlapi.types.utils.XMLBaseModel.from_xml": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_config": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel.model_computed_fields": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.parse_datetime": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.parse_time": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.Datetime": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.single_xpath": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.pd": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.sx": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.mksx": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.ensure_list": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.List": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.ensure_str": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.validate_ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.String": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.Ip": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.schematype": {"tf": 2.8284271247461903}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.jsonschema": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.xml2jsonschema": {"tf": 1.7320508075688772}}, "df": 697, "w": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 3}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 40, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}}, "df": 5}}}, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 2, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 33}}}}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.4142135623730951}}, "df": 1, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.4142135623730951}}, "df": 1}}}}, "y": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 1}, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 1}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 7}}}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 34, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 6}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 5}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}}, "df": 1, ":": {"4": {"4": {"3": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}}, "df": 2}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}}, "df": 2}}}}}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 36, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}}, "df": 6}}}}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}}}, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33}}}, "h": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}}, "df": 5}}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 2}}}}}}}, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 6, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2.449489742783178}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2.449489742783178}}, "df": 40}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 40}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 4, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 1}}}}}}}, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 36}}}}}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}}, "df": 2}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1, "h": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.restapi.PanoramaClient": {"tf": 2.449489742783178}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.create": {"tf": 2}, "pa_api.xmlapi.XMLApi.update": {"tf": 2.449489742783178}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 3.4641016151377544}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 2.6457513110645907}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 2}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 2}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 3}, "pa_api.xmlapi.types.config.address.Address": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 4.898979485566356}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 2}}, "df": 84, "i": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}}, "df": 3}}, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}}, "df": 2}, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}}, "m": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}, "i": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 50}}, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 7}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}, "o": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 47}, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 2}}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 3, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 12}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}}}}}}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}}, "df": 4, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.7320508075688772}}, "df": 2}}}, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}}, "df": 1}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 2, "s": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.7320508075688772}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 2}}}}, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 8}}}}, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 4.358898943540674}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 34}}}}}}}, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 9}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 1}}}}}}}, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33}}}}}}, "o": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}, "s": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 3}}}}}, "r": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}}, "df": 3, "/": {"1": {"0": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "b": {"docs": {}, "df": 0, "j": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}}, "df": 6, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "n": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 40, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 16}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}, "e": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}, "f": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 3.1622776601683795}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 3.1622776601683795}}, "df": 55}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 2}}}}, "r": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 36, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 3}}}}}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}}}, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 8}}}, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}}}, "o": {"docs": {}, "df": 0, "k": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}, "h": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, ":": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}}, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 35}}}}}}}}}}, "m": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "#": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "o": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.7320508075688772}}, "df": 4, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}}, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.7320508075688772}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.7320508075688772}}, "df": 2, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.7320508075688772}}, "df": 2}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 2}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 2}}, "df": 2}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 4}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}}, "df": 2}}}}}, "p": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}}, "df": 4}}}}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 9, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 6}, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 4}}}}}, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}}, "df": 4}}}}}}, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.delete": {"tf": 1}}, "df": 1}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.7320508075688772}}, "df": 1}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 4}}}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 2, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}}}}}}}, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}}, "df": 3}}}}}}, "a": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 1}}, "o": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33, "m": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "/": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}}}}}}}}}}}}, "n": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 41, "i": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama.__init__": {"tf": 1}}, "df": 1}}}}}}}}, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}}, "df": 1}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.install_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 2.449489742783178}}, "df": 3, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}, "f": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 6, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}}, "df": 2}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 1}}}, "c": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}}, "df": 2}}}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 5}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 52}, "f": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 44}, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 5}, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 54, "d": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}}, "df": 3}}}}}}}}, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1.4142135623730951}, "pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 2}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 42}, "g": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 40, "d": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 40}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 1}}}}}}}}}}}, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.restapi.PanoramaClient": {"tf": 2.23606797749979}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.commit_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 10, "o": {"docs": {}, "df": 0, "w": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}, "p": {"docs": {}, "df": 0, "i": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 8, "/": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}, "#": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"0": {"docs": {}, "df": 0, "e": {"5": {"3": {"6": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "a": {"4": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "docs": {}, "df": 0}}}, "docs": {}, "df": 0}, "docs": {}, "df": 0}, "docs": {}, "df": 0}}, "docs": {}, "df": 0}}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 33, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 35}}}}}}}}}, "b": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 36}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 2}}, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}}, "df": 1}}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 17}, "u": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 35, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}}}}}}}, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "b": {"7": {"0": {"docs": {}, "df": 0, "f": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}, "docs": {}, "df": 0}, "docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}, "pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 41, "g": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33, "d": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}, "y": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 37}, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}, "u": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 2}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 5, "c": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 2}}, "df": 35, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}}}}, "t": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 3}}}}}}}}, "o": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}}, "e": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 5}, "r": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 3}}}, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}}, "df": 1, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}, "c": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 34}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}}, "df": 2}, "u": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}}, "df": 2}}}}, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}}}, "r": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 6}}}}}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.system_resources": {"tf": 1.4142135623730951}}, "df": 1}}}}}, "u": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaObjectsResourceType": {"tf": 1}, "pa_api.restapi.rest_resources.PanoramaPoliciesResourceType": {"tf": 1}}, "df": 4}}}}}}}}, "s": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}}, "df": 1}}}}}, "c": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}}, "k": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 3}}}}}}}, "a": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 2}}}, "y": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}}, "df": 1, "h": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "z": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}}}}}}}}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {"pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 2}}, "df": 4}}}}}}}, "i": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}, "m": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 34}}}}}}}, "m": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1}}}}}}}, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}}, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}}, "df": 2}}, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}}, "df": 1, "p": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1, "[": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}}}}}}}}}}}, "y": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}}}}, "s": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 5}}}, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "b": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34}}}, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2}}, "df": 33}}}}}}}, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 4}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 4}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 4}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 4}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 4}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 4}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 4}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 4}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 4}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 4}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 4}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 4}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 4}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 4}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 4}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 4}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 4}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 4}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 4}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 4}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 4}}, "df": 33, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 33}}}, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}, "v": {"1": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}, "docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.panorama.Panorama": {"tf": 1}}, "df": 1, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33, "d": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.validate_changes": {"tf": 1}}, "df": 2}}, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 37}}}}, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}, "l": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "i": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}}}}}}}, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1.4142135623730951}}, "df": 5, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}}, "df": 1}}}}}}}, "p": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}}, "df": 1}}}, "e": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 4, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}}}}}}}}}}}}}}}}, "x": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 4}}, "m": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}}, "t": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 33}}}, "p": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}}, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 3}}}}}}, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}}}, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}}, "df": 1}}}}}, "a": {"docs": {}, "df": 0, "s": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1}}, "df": 1}}}}}, "n": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.operations.job.JobResult": {"tf": 1}}, "df": 1}}}}}}}}}}}, "g": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 4, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}}, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 2.23606797749979}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 2}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1}, "o": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}, "i": {"docs": {}, "df": 0, "c": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_versions": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_info": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs_map": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_panorama_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_resources": {"tf": 1}}, "df": 11}}, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}}, "df": 3}}}}}, "u": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 3}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}}}}, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}, "s": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1, "r": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1}}, "f": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 1}}}}, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.devicegroup.DeviceGroup": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 2.23606797749979}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 2.23606797749979}}, "df": 34}}, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "g": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 2}}}, "a": {"docs": {}, "df": 0, "g": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}}, "p": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}}, "df": 1}}}}}}}, "n": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}}, "df": 2}, "m": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 34, "d": {"docs": {"pa_api.xmlapi.XMLApi.save_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}}, "df": 2}, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}, "pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 35, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}}, "e": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "k": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.rest_resources.PanoramaNetworkResourceType": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}}, "df": 3}}}}}, "w": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 2}, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}, "o": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 7, "e": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_vpn_flows": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 10}}, "n": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}}, "df": 1, "e": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 2}}}, "b": {"docs": {"pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 1}}, "d": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.uncommited_changes_summary": {"tf": 1}, "pa_api.xmlapi.XMLApi.save_device_state": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 2.23606797749979}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.restart": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 11, "g": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "p": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.restapi.PanoramaClient": {"tf": 1}, "pa_api.restapi.restapi.PanoramaClient": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}}, "df": 3}}}}}}, "s": {"docs": {"pa_api.restapi.rest_resources.PanoramaDevicesResourceType": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_ha_pairs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 5}}}}, "/": {"2": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}, "docs": {}, "df": 0}}, "f": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}}, "df": 4}}}}}, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.7320508075688772}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.7320508075688772}}, "df": 33}}}}, "a": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 4, "s": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2}}}}}}, "t": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 2}}}}}}, "a": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "i": {"docs": {}, "df": 0, "v": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.set_ha_status": {"tf": 1}, "pa_api.xmlapi.XMLApi.set_ha_preemption": {"tf": 1}}, "df": 2}}}}}}}}, "p": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}, "s": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "d": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}}}}}}, "c": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1.4142135623730951}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1.4142135623730951}}, "df": 33}}}}}}}}}, "i": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "f": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}}, "df": 1}}}}}}}}}, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}, "r": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "c": {"docs": {}, "df": 0, "t": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devicegroups_name": {"tf": 1}}, "df": 2}}}}}, "o": {"docs": {"pa_api.xmlapi.XMLApi.revert_changes": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}}, "df": 2, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 2, "n": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}, "w": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.download_software": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.automatic_download_software": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 2}}, "df": 4}}}}}}, "c": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}}, "df": 33}}}, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "e": {"docs": {"pa_api.xmlapi.XMLApi.get_templates_sync_status": {"tf": 1}}, "df": 1}, "a": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 34}}}, "u": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "p": {"docs": {"pa_api.xmlapi.types.config.address.Address": {"tf": 1}, "pa_api.xmlapi.types.config.interface.GenericInterface": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer2": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Layer3": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Vlan": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Ethernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.AggregateEthernet": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Tunnel": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Loopback": {"tf": 1}, "pa_api.xmlapi.types.config.interface.Interface": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.NextHop": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.StaticRoute": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.IPv4RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.routing.routing_table.RoutingTable": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIPAndPort": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DynamicIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.StaticIP": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.SourceTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.DestinationTranslation": {"tf": 1}, "pa_api.xmlapi.types.config.rules.nat.NAT": {"tf": 1}, "pa_api.xmlapi.types.config.rules.rulebase.RuleBase": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.ProfileSetting": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Option": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Target": {"tf": 1}, "pa_api.xmlapi.types.config.rules.security.Security": {"tf": 1}, "pa_api.xmlapi.types.config.zone.ZoneNetwork": {"tf": 1}, "pa_api.xmlapi.types.config.zone.Zone": {"tf": 1}, "pa_api.xmlapi.types.operations.device.Device": {"tf": 1}, "pa_api.xmlapi.types.operations.device.VPNFlow": {"tf": 1}, "pa_api.xmlapi.types.operations.device.HAInfo": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleHit": {"tf": 1}, "pa_api.xmlapi.types.statistics.RuleUse": {"tf": 1}, "pa_api.xmlapi.types.utils.XMLBaseModel": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1}}, "df": 34, "e": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}}, "df": 1}}}}}}, "k": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.generate_apikey": {"tf": 1}}, "df": 1, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_plan_dg_hierarchy": {"tf": 1}}, "df": 1}}}, "n": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "w": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.XMLApi.get_tree": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_devices": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_addresses": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_routing_tables": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_interfaces": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 6}}}}}, "x": {"docs": {}, "df": 0, "m": {"docs": {}, "df": 0, "l": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1}, "pa_api.xmlapi.XMLApi.create": {"tf": 1}, "pa_api.xmlapi.XMLApi.update": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_named_configuration": {"tf": 1}, "pa_api.xmlapi.XMLApi.candidate_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.running_config": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.system_info": {"tf": 1}, "pa_api.xmlapi.types.utils.xml2schematype": {"tf": 1}}, "df": 10}}, "p": {"docs": {}, "df": 0, "a": {"docs": {}, "df": 0, "t": {"docs": {}, "df": 0, "h": {"docs": {"pa_api.xmlapi.XMLApi.get": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.delete": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.create": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.update": {"tf": 1.4142135623730951}, "pa_api.xmlapi.XMLApi.get_push_scope_devicegroups": {"tf": 1}, "pa_api.xmlapi.XMLApi.uncommited_changes": {"tf": 1}}, "df": 6}}}}}, "y": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.pending_changes": {"tf": 1}}, "df": 1}}, "i": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "l": {"docs": {}, "df": 0, "d": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}, "o": {"docs": {}, "df": 0, "u": {"docs": {"pa_api.xmlapi.XMLApi.automatic_software_upgrade": {"tf": 1}}, "df": 1}}}, "j": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "b": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1.7320508075688772}, "pa_api.xmlapi.XMLApi.download_software": {"tf": 1}, "pa_api.xmlapi.XMLApi.install_software": {"tf": 1}}, "df": 5, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_jobs": {"tf": 1}, "pa_api.xmlapi.XMLApi.get_job": {"tf": 1}, "pa_api.xmlapi.XMLApi.raw_get_pending_jobs": {"tf": 1}}, "df": 3}}}, "s": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {"pa_api.xmlapi.types.utils.xml2schema": {"tf": 1}, "pa_api.xmlapi.types.utils.schematype": {"tf": 1.4142135623730951}}, "df": 2}}}}, "q": {"docs": {}, "df": 0, "u": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "r": {"docs": {}, "df": 0, "y": {"docs": {"pa_api.xmlapi.XMLApi.wait_job_completion": {"tf": 1}}, "df": 1}}}}}, "z": {"docs": {}, "df": 0, "o": {"docs": {}, "df": 0, "n": {"docs": {}, "df": 0, "e": {"docs": {}, "df": 0, "s": {"docs": {"pa_api.xmlapi.XMLApi.get_zones": {"tf": 1}}, "df": 1}}}}}}}}, "pipeline": ["trimmer"], "_isPrebuiltIndex": true}; + + // mirrored in build-search-index.js (part 1) + // Also split on html tags. this is a cheap heuristic, but good enough. + elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/); + + let searchIndex; + if (docs._isPrebuiltIndex) { + console.info("using precompiled search index"); + searchIndex = elasticlunr.Index.load(docs); + } else { + console.time("building search index"); + // mirrored in build-search-index.js (part 2) + searchIndex = elasticlunr(function () { + this.pipeline.remove(elasticlunr.stemmer); + this.pipeline.remove(elasticlunr.stopWordFilter); + this.addField("qualname"); + this.addField("fullname"); + this.addField("annotation"); + this.addField("default_value"); + this.addField("signature"); + this.addField("bases"); + this.addField("doc"); + this.setRef("fullname"); + }); + for (let doc of docs) { + searchIndex.addDoc(doc); + } + console.timeEnd("building search index"); + } + + return (term) => searchIndex.search(term, { + fields: { + qualname: {boost: 4}, + fullname: {boost: 2}, + annotation: {boost: 2}, + default_value: {boost: 2}, + signature: {boost: 2}, + bases: {boost: 2}, + doc: {boost: 1}, + }, + expand: true + }); +})(); \ No newline at end of file diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..71d0567 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,27 @@ +[tool.poetry] +name = "pa-api-sdk" +version = "0.1.1" +description = "" +authors = ["David Gallay "] +readme = "README.md" +packages = [{include = "pa_api", from="."}] + +[tool.poetry.scripts] +pa-api = "pa_api.__main__:cli" +panorama-api = "pa_api.__main__:cli" + +[tool.poetry.dependencies] +# https://stackoverflow.com/questions/65945929/poetry-how-to-publish-project-packages-targeting-multiple-python-versions +python = ">=3.7.0,<4.0.0" +# pan-os-python = "^1.11.0" +lxml = "^4.9.3" +xmltodict = "^0.13.0" +requests = "^2.31.0" +# defusedxml = "^0.7.1" +pan-os-python = "^1.11.0" +pydantic = "^2.5.3" + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..ddaedf2 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,327 @@ +annotated-types==0.5.0 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:47cdc3490d9ac1506ce92c7aaa76c579dc3509ff11e098fc867e5130ab7be802 \ + --hash=sha256:58da39888f92c276ad970249761ebea80ba544b77acddaa1a4d6cf78287d45fd +certifi==2024.8.30 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:922820b53db7a7257ffbda3f597266d435245903d80737e34f8a45ff3e3230d8 \ + --hash=sha256:bec941d2aa8195e248a60b31ff9f0558284cf01a52591ceda73ea9afffd69fd9 +charset-normalizer==3.3.2 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027 \ + --hash=sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087 \ + --hash=sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786 \ + --hash=sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8 \ + --hash=sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09 \ + --hash=sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185 \ + --hash=sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574 \ + --hash=sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e \ + --hash=sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519 \ + --hash=sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898 \ + --hash=sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269 \ + --hash=sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3 \ + --hash=sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f \ + --hash=sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6 \ + --hash=sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8 \ + --hash=sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a \ + --hash=sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73 \ + --hash=sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc \ + --hash=sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714 \ + --hash=sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2 \ + --hash=sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc \ + --hash=sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce \ + --hash=sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d \ + --hash=sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e \ + --hash=sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6 \ + --hash=sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269 \ + --hash=sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96 \ + --hash=sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d \ + --hash=sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a \ + --hash=sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4 \ + --hash=sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77 \ + --hash=sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d \ + --hash=sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0 \ + --hash=sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed \ + --hash=sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068 \ + --hash=sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac \ + --hash=sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25 \ + --hash=sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8 \ + --hash=sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab \ + --hash=sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26 \ + --hash=sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2 \ + --hash=sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db \ + --hash=sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f \ + --hash=sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5 \ + --hash=sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99 \ + --hash=sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c \ + --hash=sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d \ + --hash=sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811 \ + --hash=sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa \ + --hash=sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a \ + --hash=sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03 \ + --hash=sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b \ + --hash=sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04 \ + --hash=sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c \ + --hash=sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001 \ + --hash=sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458 \ + --hash=sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389 \ + --hash=sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99 \ + --hash=sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985 \ + --hash=sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537 \ + --hash=sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238 \ + --hash=sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f \ + --hash=sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d \ + --hash=sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796 \ + --hash=sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a \ + --hash=sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143 \ + --hash=sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8 \ + --hash=sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c \ + --hash=sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5 \ + --hash=sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5 \ + --hash=sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711 \ + --hash=sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4 \ + --hash=sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6 \ + --hash=sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c \ + --hash=sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7 \ + --hash=sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4 \ + --hash=sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b \ + --hash=sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae \ + --hash=sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12 \ + --hash=sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c \ + --hash=sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae \ + --hash=sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8 \ + --hash=sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887 \ + --hash=sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b \ + --hash=sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4 \ + --hash=sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f \ + --hash=sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5 \ + --hash=sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33 \ + --hash=sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519 \ + --hash=sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561 +idna==3.8 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:050b4e5baadcd44d760cedbd2b8e639f2ff89bbc7a5730fcc662954303377aac \ + --hash=sha256:d838c2c0ed6fced7693d5e8ab8e734d5f8fda53a039c0164afb0b82e771e3603 +importlib-metadata==6.7.0 ; python_version == "3.7" \ + --hash=sha256:1aaf550d4f73e5d6783e7acb77aec43d49da8017410afae93822cc9cca98c4d4 \ + --hash=sha256:cb52082e659e97afc5dac71e79de97d8681de3aa07ff18578330904a9d18e5b5 +lxml==4.9.4 ; python_full_version >= "3.7.0" and python_full_version < "4.0.0" \ + --hash=sha256:00e91573183ad273e242db5585b52670eddf92bacad095ce25c1e682da14ed91 \ + --hash=sha256:01bf1df1db327e748dcb152d17389cf6d0a8c5d533ef9bab781e9d5037619229 \ + --hash=sha256:056a17eaaf3da87a05523472ae84246f87ac2f29a53306466c22e60282e54ff8 \ + --hash=sha256:0a08c89b23117049ba171bf51d2f9c5f3abf507d65d016d6e0fa2f37e18c0fc5 \ + --hash=sha256:1343df4e2e6e51182aad12162b23b0a4b3fd77f17527a78c53f0f23573663545 \ + --hash=sha256:1449f9451cd53e0fd0a7ec2ff5ede4686add13ac7a7bfa6988ff6d75cff3ebe2 \ + --hash=sha256:16b9ec51cc2feab009e800f2c6327338d6ee4e752c76e95a35c4465e80390ccd \ + --hash=sha256:1f10f250430a4caf84115b1e0f23f3615566ca2369d1962f82bef40dd99cd81a \ + --hash=sha256:231142459d32779b209aa4b4d460b175cadd604fed856f25c1571a9d78114771 \ + --hash=sha256:232fd30903d3123be4c435fb5159938c6225ee8607b635a4d3fca847003134ba \ + --hash=sha256:23d891e5bdc12e2e506e7d225d6aa929e0a0368c9916c1fddefab88166e98b20 \ + --hash=sha256:266f655d1baff9c47b52f529b5f6bec33f66042f65f7c56adde3fcf2ed62ae8b \ + --hash=sha256:273473d34462ae6e97c0f4e517bd1bf9588aa67a1d47d93f760a1282640e24ac \ + --hash=sha256:2bd9ac6e44f2db368ef8986f3989a4cad3de4cd55dbdda536e253000c801bcc7 \ + --hash=sha256:33714fcf5af4ff7e70a49731a7cc8fd9ce910b9ac194f66eaa18c3cc0a4c02be \ + --hash=sha256:359a8b09d712df27849e0bcb62c6a3404e780b274b0b7e4c39a88826d1926c28 \ + --hash=sha256:365005e8b0718ea6d64b374423e870648ab47c3a905356ab6e5a5ff03962b9a9 \ + --hash=sha256:389d2b2e543b27962990ab529ac6720c3dded588cc6d0f6557eec153305a3622 \ + --hash=sha256:3b505f2bbff50d261176e67be24e8909e54b5d9d08b12d4946344066d66b3e43 \ + --hash=sha256:3d74d4a3c4b8f7a1f676cedf8e84bcc57705a6d7925e6daef7a1e54ae543a197 \ + --hash=sha256:3f3f00a9061605725df1816f5713d10cd94636347ed651abdbc75828df302b20 \ + --hash=sha256:43498ea734ccdfb92e1886dfedaebeb81178a241d39a79d5351ba2b671bff2b2 \ + --hash=sha256:4855161013dfb2b762e02b3f4d4a21cc7c6aec13c69e3bffbf5022b3e708dd97 \ + --hash=sha256:4d973729ce04784906a19108054e1fd476bc85279a403ea1a72fdb051c76fa48 \ + --hash=sha256:4ece9cca4cd1c8ba889bfa67eae7f21d0d1a2e715b4d5045395113361e8c533d \ + --hash=sha256:506becdf2ecaebaf7f7995f776394fcc8bd8a78022772de66677c84fb02dd33d \ + --hash=sha256:520486f27f1d4ce9654154b4494cf9307b495527f3a2908ad4cb48e4f7ed7ef7 \ + --hash=sha256:5557461f83bb7cc718bc9ee1f7156d50e31747e5b38d79cf40f79ab1447afd2d \ + --hash=sha256:562778586949be7e0d7435fcb24aca4810913771f845d99145a6cee64d5b67ca \ + --hash=sha256:59bb5979f9941c61e907ee571732219fa4774d5a18f3fa5ff2df963f5dfaa6bc \ + --hash=sha256:606d445feeb0856c2b424405236a01c71af7c97e5fe42fbc778634faef2b47e4 \ + --hash=sha256:6197c3f3c0b960ad033b9b7d611db11285bb461fc6b802c1dd50d04ad715c225 \ + --hash=sha256:647459b23594f370c1c01768edaa0ba0959afc39caeeb793b43158bb9bb6a663 \ + --hash=sha256:647bfe88b1997d7ae8d45dabc7c868d8cb0c8412a6e730a7651050b8c7289cf2 \ + --hash=sha256:6bee9c2e501d835f91460b2c904bc359f8433e96799f5c2ff20feebd9bb1e590 \ + --hash=sha256:6dbdacf5752fbd78ccdb434698230c4f0f95df7dd956d5f205b5ed6911a1367c \ + --hash=sha256:701847a7aaefef121c5c0d855b2affa5f9bd45196ef00266724a80e439220e46 \ + --hash=sha256:786d6b57026e7e04d184313c1359ac3d68002c33e4b1042ca58c362f1d09ff58 \ + --hash=sha256:7b378847a09d6bd46047f5f3599cdc64fcb4cc5a5a2dd0a2af610361fbe77b16 \ + --hash=sha256:7d1d6c9e74c70ddf524e3c09d9dc0522aba9370708c2cb58680ea40174800013 \ + --hash=sha256:857d6565f9aa3464764c2cb6a2e3c2e75e1970e877c188f4aeae45954a314e0c \ + --hash=sha256:8671622256a0859f5089cbe0ce4693c2af407bc053dcc99aadff7f5310b4aa02 \ + --hash=sha256:88f7c383071981c74ec1998ba9b437659e4fd02a3c4a4d3efc16774eb108d0ec \ + --hash=sha256:8aecb5a7f6f7f8fe9cac0bcadd39efaca8bbf8d1bf242e9f175cbe4c925116c3 \ + --hash=sha256:91bbf398ac8bb7d65a5a52127407c05f75a18d7015a270fdd94bbcb04e65d573 \ + --hash=sha256:936e8880cc00f839aa4173f94466a8406a96ddce814651075f95837316369899 \ + --hash=sha256:953dd5481bd6252bd480d6ec431f61d7d87fdcbbb71b0d2bdcfc6ae00bb6fb10 \ + --hash=sha256:95ae6c5a196e2f239150aa4a479967351df7f44800c93e5a975ec726fef005e2 \ + --hash=sha256:9a2b5915c333e4364367140443b59f09feae42184459b913f0f41b9fed55794a \ + --hash=sha256:9ae6c3363261021144121427b1552b29e7b59de9d6a75bf51e03bc072efb3c37 \ + --hash=sha256:9b556596c49fa1232b0fff4b0e69b9d4083a502e60e404b44341e2f8fb7187f5 \ + --hash=sha256:9c131447768ed7bc05a02553d939e7f0e807e533441901dd504e217b76307745 \ + --hash=sha256:9d9d5726474cbbef279fd709008f91a49c4f758bec9c062dfbba88eab00e3ff9 \ + --hash=sha256:a1bdcbebd4e13446a14de4dd1825f1e778e099f17f79718b4aeaf2403624b0f7 \ + --hash=sha256:a602ed9bd2c7d85bd58592c28e101bd9ff9c718fbde06545a70945ffd5d11868 \ + --hash=sha256:a8edae5253efa75c2fc79a90068fe540b197d1c7ab5803b800fccfe240eed33c \ + --hash=sha256:a905affe76f1802edcac554e3ccf68188bea16546071d7583fb1b693f9cf756b \ + --hash=sha256:a9e7c6d89c77bb2770c9491d988f26a4b161d05c8ca58f63fb1f1b6b9a74be45 \ + --hash=sha256:aa9b5abd07f71b081a33115d9758ef6077924082055005808f68feccb27616bd \ + --hash=sha256:aaa5c173a26960fe67daa69aa93d6d6a1cd714a6eb13802d4e4bd1d24a530644 \ + --hash=sha256:ac7674d1638df129d9cb4503d20ffc3922bd463c865ef3cb412f2c926108e9a4 \ + --hash=sha256:b1541e50b78e15fa06a2670157a1962ef06591d4c998b998047fff5e3236880e \ + --hash=sha256:b1980dbcaad634fe78e710c8587383e6e3f61dbe146bcbfd13a9c8ab2d7b1192 \ + --hash=sha256:bafa65e3acae612a7799ada439bd202403414ebe23f52e5b17f6ffc2eb98c2be \ + --hash=sha256:bb5bd6212eb0edfd1e8f254585290ea1dadc3687dd8fd5e2fd9a87c31915cdab \ + --hash=sha256:bbdd69e20fe2943b51e2841fc1e6a3c1de460d630f65bde12452d8c97209464d \ + --hash=sha256:bc354b1393dce46026ab13075f77b30e40b61b1a53e852e99d3cc5dd1af4bc85 \ + --hash=sha256:bcee502c649fa6351b44bb014b98c09cb00982a475a1912a9881ca28ab4f9cd9 \ + --hash=sha256:bdd9abccd0927673cffe601d2c6cdad1c9321bf3437a2f507d6b037ef91ea307 \ + --hash=sha256:c42ae7e010d7d6bc51875d768110c10e8a59494855c3d4c348b068f5fb81fdcd \ + --hash=sha256:c71b5b860c5215fdbaa56f715bc218e45a98477f816b46cfde4a84d25b13274e \ + --hash=sha256:c7721a3ef41591341388bb2265395ce522aba52f969d33dacd822da8f018aff8 \ + --hash=sha256:ca8e44b5ba3edb682ea4e6185b49661fc22b230cf811b9c13963c9f982d1d964 \ + --hash=sha256:cb53669442895763e61df5c995f0e8361b61662f26c1b04ee82899c2789c8f69 \ + --hash=sha256:cc02c06e9e320869d7d1bd323df6dd4281e78ac2e7f8526835d3d48c69060683 \ + --hash=sha256:d3caa09e613ece43ac292fbed513a4bce170681a447d25ffcbc1b647d45a39c5 \ + --hash=sha256:d82411dbf4d3127b6cde7da0f9373e37ad3a43e89ef374965465928f01c2b979 \ + --hash=sha256:dbcb2dc07308453db428a95a4d03259bd8caea97d7f0776842299f2d00c72fc8 \ + --hash=sha256:dd4fda67f5faaef4f9ee5383435048ee3e11ad996901225ad7615bc92245bc8e \ + --hash=sha256:ddd92e18b783aeb86ad2132d84a4b795fc5ec612e3545c1b687e7747e66e2b53 \ + --hash=sha256:de362ac8bc962408ad8fae28f3967ce1a262b5d63ab8cefb42662566737f1dc7 \ + --hash=sha256:e214025e23db238805a600f1f37bf9f9a15413c7bf5f9d6ae194f84980c78722 \ + --hash=sha256:e8f9f93a23634cfafbad6e46ad7d09e0f4a25a2400e4a64b1b7b7c0fbaa06d9d \ + --hash=sha256:e96a1788f24d03e8d61679f9881a883ecdf9c445a38f9ae3f3f193ab6c591c66 \ + --hash=sha256:ec53a09aee61d45e7dbe7e91252ff0491b6b5fee3d85b2d45b173d8ab453efc1 \ + --hash=sha256:f10250bb190fb0742e3e1958dd5c100524c2cc5096c67c8da51233f7448dc137 \ + --hash=sha256:f1faee2a831fe249e1bae9cbc68d3cd8a30f7e37851deee4d7962b17c410dd56 \ + --hash=sha256:f610d980e3fccf4394ab3806de6065682982f3d27c12d4ce3ee46a8183d64a6a \ + --hash=sha256:f6c35b2f87c004270fa2e703b872fcc984d714d430b305145c39d53074e1ffe0 \ + --hash=sha256:f836f39678cb47c9541f04d8ed4545719dc31ad850bf1832d6b4171e30d65d23 \ + --hash=sha256:f99768232f036b4776ce419d3244a04fe83784bce871b16d2c2e984c7fcea847 \ + --hash=sha256:fd814847901df6e8de13ce69b84c31fc9b3fb591224d6762d0b256d510cbf382 \ + --hash=sha256:fdb325b7fba1e2c40b9b1db407f85642e32404131c08480dd652110fc908561b +pan-os-python==1.12.1 ; python_full_version >= "3.7.0" and python_full_version < "4.0.0" \ + --hash=sha256:41d7871547919cb5c3b7d3ebe8c9d1797b8a938c8366b53307e64375d65e69dc \ + --hash=sha256:71d149e259c2077f83beebe29b25a8b4e53adbd28c12cb167065a010d2e92368 +pan-python==0.17.0 ; python_full_version >= "3.7.0" and python_full_version < "4.0.0" \ + --hash=sha256:9c074ea2f69a63996a6fefe8935d60dca61660e14715ac19d257ea9b1c41c6e2 \ + --hash=sha256:f4674e40763c46d5933244b3059a57884e4e28205ef6d0f9ce2dc2013e3db010 +pydantic-core==2.14.6 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:00646784f6cd993b1e1c0e7b0fdcbccc375d539db95555477771c27555e3c556 \ + --hash=sha256:00b1087dabcee0b0ffd104f9f53d7d3eaddfaa314cdd6726143af6bc713aa27e \ + --hash=sha256:0348b1dc6b76041516e8a854ff95b21c55f5a411c3297d2ca52f5528e49d8411 \ + --hash=sha256:036137b5ad0cb0004c75b579445a1efccd072387a36c7f217bb8efd1afbe5245 \ + --hash=sha256:095b707bb287bfd534044166ab767bec70a9bba3175dcdc3371782175c14e43c \ + --hash=sha256:0c08de15d50fa190d577e8591f0329a643eeaed696d7771760295998aca6bc66 \ + --hash=sha256:1302a54f87b5cd8528e4d6d1bf2133b6aa7c6122ff8e9dc5220fbc1e07bffebd \ + --hash=sha256:172de779e2a153d36ee690dbc49c6db568d7b33b18dc56b69a7514aecbcf380d \ + --hash=sha256:1b027c86c66b8627eb90e57aee1f526df77dc6d8b354ec498be9a757d513b92b \ + --hash=sha256:1ce830e480f6774608dedfd4a90c42aac4a7af0a711f1b52f807130c2e434c06 \ + --hash=sha256:1fd0c1d395372843fba13a51c28e3bb9d59bd7aebfeb17358ffaaa1e4dbbe948 \ + --hash=sha256:23598acb8ccaa3d1d875ef3b35cb6376535095e9405d91a3d57a8c7db5d29341 \ + --hash=sha256:24368e31be2c88bd69340fbfe741b405302993242ccb476c5c3ff48aeee1afe0 \ + --hash=sha256:26a92ae76f75d1915806b77cf459811e772d8f71fd1e4339c99750f0e7f6324f \ + --hash=sha256:27e524624eace5c59af499cd97dc18bb201dc6a7a2da24bfc66ef151c69a5f2a \ + --hash=sha256:2b8719037e570639e6b665a4050add43134d80b687288ba3ade18b22bbb29dd2 \ + --hash=sha256:2c5bcf3414367e29f83fd66f7de64509a8fd2368b1edf4351e862910727d3e51 \ + --hash=sha256:2dbe357bc4ddda078f79d2a36fc1dd0494a7f2fad83a0a684465b6f24b46fe80 \ + --hash=sha256:2f5fa187bde8524b1e37ba894db13aadd64faa884657473b03a019f625cee9a8 \ + --hash=sha256:2f6ffc6701a0eb28648c845f4945a194dc7ab3c651f535b81793251e1185ac3d \ + --hash=sha256:314ccc4264ce7d854941231cf71b592e30d8d368a71e50197c905874feacc8a8 \ + --hash=sha256:36026d8f99c58d7044413e1b819a67ca0e0b8ebe0f25e775e6c3d1fabb3c38fb \ + --hash=sha256:36099c69f6b14fc2c49d7996cbf4f87ec4f0e66d1c74aa05228583225a07b590 \ + --hash=sha256:36fa402dcdc8ea7f1b0ddcf0df4254cc6b2e08f8cd80e7010d4c4ae6e86b2a87 \ + --hash=sha256:370ffecb5316ed23b667d99ce4debe53ea664b99cc37bfa2af47bc769056d534 \ + --hash=sha256:3860c62057acd95cc84044e758e47b18dcd8871a328ebc8ccdefd18b0d26a21b \ + --hash=sha256:399ac0891c284fa8eb998bcfa323f2234858f5d2efca3950ae58c8f88830f145 \ + --hash=sha256:3a0b5db001b98e1c649dd55afa928e75aa4087e587b9524a4992316fa23c9fba \ + --hash=sha256:3dcf1978be02153c6a31692d4fbcc2a3f1db9da36039ead23173bc256ee3b91b \ + --hash=sha256:4241204e4b36ab5ae466ecec5c4c16527a054c69f99bba20f6f75232a6a534e2 \ + --hash=sha256:438027a975cc213a47c5d70672e0d29776082155cfae540c4e225716586be75e \ + --hash=sha256:43e166ad47ba900f2542a80d83f9fc65fe99eb63ceec4debec160ae729824052 \ + --hash=sha256:478e9e7b360dfec451daafe286998d4a1eeaecf6d69c427b834ae771cad4b622 \ + --hash=sha256:4ce8299b481bcb68e5c82002b96e411796b844d72b3e92a3fbedfe8e19813eab \ + --hash=sha256:4f86f1f318e56f5cbb282fe61eb84767aee743ebe32c7c0834690ebea50c0a6b \ + --hash=sha256:55a23dcd98c858c0db44fc5c04fc7ed81c4b4d33c653a7c45ddaebf6563a2f66 \ + --hash=sha256:599c87d79cab2a6a2a9df4aefe0455e61e7d2aeede2f8577c1b7c0aec643ee8e \ + --hash=sha256:5aa90562bc079c6c290f0512b21768967f9968e4cfea84ea4ff5af5d917016e4 \ + --hash=sha256:64634ccf9d671c6be242a664a33c4acf12882670b09b3f163cd00a24cffbd74e \ + --hash=sha256:667aa2eac9cd0700af1ddb38b7b1ef246d8cf94c85637cbb03d7757ca4c3fdec \ + --hash=sha256:6a31d98c0d69776c2576dda4b77b8e0c69ad08e8b539c25c7d0ca0dc19a50d6c \ + --hash=sha256:6af4b3f52cc65f8a0bc8b1cd9676f8c21ef3e9132f21fed250f6958bd7223bed \ + --hash=sha256:6c8edaea3089bf908dd27da8f5d9e395c5b4dc092dbcce9b65e7156099b4b937 \ + --hash=sha256:71d72ca5eaaa8d38c8df16b7deb1a2da4f650c41b58bb142f3fb75d5ad4a611f \ + --hash=sha256:72f9a942d739f09cd42fffe5dc759928217649f070056f03c70df14f5770acf9 \ + --hash=sha256:747265448cb57a9f37572a488a57d873fd96bf51e5bb7edb52cfb37124516da4 \ + --hash=sha256:75ec284328b60a4e91010c1acade0c30584f28a1f345bc8f72fe8b9e46ec6a96 \ + --hash=sha256:78d0768ee59baa3de0f4adac9e3748b4b1fffc52143caebddfd5ea2961595277 \ + --hash=sha256:78ee52ecc088c61cce32b2d30a826f929e1708f7b9247dc3b921aec367dc1b23 \ + --hash=sha256:7be719e4d2ae6c314f72844ba9d69e38dff342bc360379f7c8537c48e23034b7 \ + --hash=sha256:7e1f4744eea1501404b20b0ac059ff7e3f96a97d3e3f48ce27a139e053bb370b \ + --hash=sha256:7e90d6cc4aad2cc1f5e16ed56e46cebf4877c62403a311af20459c15da76fd91 \ + --hash=sha256:7ebe3416785f65c28f4f9441e916bfc8a54179c8dea73c23023f7086fa601c5d \ + --hash=sha256:7f41533d7e3cf9520065f610b41ac1c76bc2161415955fbcead4981b22c7611e \ + --hash=sha256:7f5025db12fc6de7bc1104d826d5aee1d172f9ba6ca936bf6474c2148ac336c1 \ + --hash=sha256:86c963186ca5e50d5c8287b1d1c9d3f8f024cbe343d048c5bd282aec2d8641f2 \ + --hash=sha256:86ce5fcfc3accf3a07a729779d0b86c5d0309a4764c897d86c11089be61da160 \ + --hash=sha256:8a14c192c1d724c3acbfb3f10a958c55a2638391319ce8078cb36c02283959b9 \ + --hash=sha256:8b93785eadaef932e4fe9c6e12ba67beb1b3f1e5495631419c784ab87e975670 \ + --hash=sha256:8ed1af8692bd8d2a29d702f1a2e6065416d76897d726e45a1775b1444f5928a7 \ + --hash=sha256:92879bce89f91f4b2416eba4429c7b5ca22c45ef4a499c39f0c5c69257522c7c \ + --hash=sha256:94fc0e6621e07d1e91c44e016cc0b189b48db053061cc22d6298a611de8071bb \ + --hash=sha256:982487f8931067a32e72d40ab6b47b1628a9c5d344be7f1a4e668fb462d2da42 \ + --hash=sha256:9862bf828112e19685b76ca499b379338fd4c5c269d897e218b2ae8fcb80139d \ + --hash=sha256:99b14dbea2fdb563d8b5a57c9badfcd72083f6006caf8e126b491519c7d64ca8 \ + --hash=sha256:9c6a5c79b28003543db3ba67d1df336f253a87d3112dac3a51b94f7d48e4c0e1 \ + --hash=sha256:a19b794f8fe6569472ff77602437ec4430f9b2b9ec7a1105cfd2232f9ba355e6 \ + --hash=sha256:a306cdd2ad3a7d795d8e617a58c3a2ed0f76c8496fb7621b6cd514eb1532cae8 \ + --hash=sha256:a3dde6cac75e0b0902778978d3b1646ca9f438654395a362cb21d9ad34b24acf \ + --hash=sha256:a874f21f87c485310944b2b2734cd6d318765bcbb7515eead33af9641816506e \ + --hash=sha256:a983cca5ed1dd9a35e9e42ebf9f278d344603bfcb174ff99a5815f953925140a \ + --hash=sha256:aca48506a9c20f68ee61c87f2008f81f8ee99f8d7f0104bff3c47e2d148f89d9 \ + --hash=sha256:b2602177668f89b38b9f84b7b3435d0a72511ddef45dc14446811759b82235a1 \ + --hash=sha256:b3e5fe4538001bb82e2295b8d2a39356a84694c97cb73a566dc36328b9f83b40 \ + --hash=sha256:b6ca36c12a5120bad343eef193cc0122928c5c7466121da7c20f41160ba00ba2 \ + --hash=sha256:b89f4477d915ea43b4ceea6756f63f0288941b6443a2b28c69004fe07fde0d0d \ + --hash=sha256:b9a9d92f10772d2a181b5ca339dee066ab7d1c9a34ae2421b2a52556e719756f \ + --hash=sha256:c99462ffc538717b3e60151dfaf91125f637e801f5ab008f81c402f1dff0cd0f \ + --hash=sha256:cb92f9061657287eded380d7dc455bbf115430b3aa4741bdc662d02977e7d0af \ + --hash=sha256:cdee837710ef6b56ebd20245b83799fce40b265b3b406e51e8ccc5b85b9099b7 \ + --hash=sha256:cf10b7d58ae4a1f07fccbf4a0a956d705356fea05fb4c70608bb6fa81d103cda \ + --hash=sha256:d15687d7d7f40333bd8266f3814c591c2e2cd263fa2116e314f60d82086e353a \ + --hash=sha256:d5c28525c19f5bb1e09511669bb57353d22b94cf8b65f3a8d141c389a55dec95 \ + --hash=sha256:d5f916acf8afbcab6bacbb376ba7dc61f845367901ecd5e328fc4d4aef2fcab0 \ + --hash=sha256:dab03ed811ed1c71d700ed08bde8431cf429bbe59e423394f0f4055f1ca0ea60 \ + --hash=sha256:db453f2da3f59a348f514cfbfeb042393b68720787bbef2b4c6068ea362c8149 \ + --hash=sha256:de2a0645a923ba57c5527497daf8ec5df69c6eadf869e9cd46e86349146e5975 \ + --hash=sha256:dea7fcd62915fb150cdc373212141a30037e11b761fbced340e9db3379b892d4 \ + --hash=sha256:dfcbebdb3c4b6f739a91769aea5ed615023f3c88cb70df812849aef634c25fbe \ + --hash=sha256:dfcebb950aa7e667ec226a442722134539e77c575f6cfaa423f24371bb8d2e94 \ + --hash=sha256:e0641b506486f0b4cd1500a2a65740243e8670a2549bb02bc4556a83af84ae03 \ + --hash=sha256:e33b0834f1cf779aa839975f9d8755a7c2420510c0fa1e9fa0497de77cd35d2c \ + --hash=sha256:e4ace1e220b078c8e48e82c081e35002038657e4b37d403ce940fa679e57113b \ + --hash=sha256:e4cf2d5829f6963a5483ec01578ee76d329eb5caf330ecd05b3edd697e7d768a \ + --hash=sha256:e574de99d735b3fc8364cba9912c2bec2da78775eba95cbb225ef7dda6acea24 \ + --hash=sha256:e646c0e282e960345314f42f2cea5e0b5f56938c093541ea6dbf11aec2862391 \ + --hash=sha256:e8a5ac97ea521d7bde7621d86c30e86b798cdecd985723c4ed737a2aa9e77d0c \ + --hash=sha256:eedf97be7bc3dbc8addcef4142f4b4164066df0c6f36397ae4aaed3eb187d8ab \ + --hash=sha256:ef633add81832f4b56d3b4c9408b43d530dfca29e68fb1b797dcb861a2c734cd \ + --hash=sha256:f27207e8ca3e5e021e2402ba942e5b4c629718e665c81b8b306f3c8b1ddbb786 \ + --hash=sha256:f85f3843bdb1fe80e8c206fe6eed7a1caeae897e496542cee499c374a85c6e08 \ + --hash=sha256:f8e81e4b55930e5ffab4a68db1af431629cf2e4066dbdbfef65348b8ab804ea8 \ + --hash=sha256:f96ae96a060a8072ceff4cfde89d261837b4294a4f28b84a28765470d502ccc6 \ + --hash=sha256:fd9e98b408384989ea4ab60206b8e100d8687da18b5c813c11e92fd8212a98e0 \ + --hash=sha256:ffff855100bc066ff2cd3aa4a60bc9534661816b110f0243e59503ec2df38421 +pydantic==2.5.3 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:b3ef57c62535b0941697cce638c08900d87fcb67e29cfa99e8a68f747f393f7a \ + --hash=sha256:d0caf5954bee831b6bfe7e338c32b9e30c85dfe080c843680783ac2b631673b4 +requests==2.31.0 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f \ + --hash=sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1 +typing-extensions==4.7.1 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:440d5dd3af93b060174bf433bccd69b0babc3b15b1a8dca43789fd7f61514b36 \ + --hash=sha256:b75ddc264f0ba5615db7ba217daeb99701ad295353c45f9e95963337ceeeffb2 +urllib3==2.0.7 ; python_version >= "3.7" and python_full_version < "4.0.0" \ + --hash=sha256:c97dfde1f7bd43a71c8d2a58e369e9b2bf692d1334ea9f9cae55add7d0dd0f84 \ + --hash=sha256:fdb6d215c776278489906c2f8916e6e7d4f5a9b602ccbcfdf7f016fc8da0596e +xmltodict==0.13.0 ; python_full_version >= "3.7.0" and python_full_version < "4.0.0" \ + --hash=sha256:341595a488e3e01a85a9d8911d8912fd922ede5fecc4dce437eb4b6c8d037e56 \ + --hash=sha256:aa89e8fd76320154a40d19a0df04a4695fb9dc5ba977cbb68ab3e4eb225e7852 +zipp==3.15.0 ; python_version == "3.7" \ + --hash=sha256:112929ad649da941c23de50f356a2b5570c954b65150642bccdd66bf194d224b \ + --hash=sha256:48904fc76a60e542af151aded95726c1a5c34ed43ab4134b597665c86d7ad556 diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 0000000..38fa960 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,87 @@ +fix = true +# Exclude a variety of commonly ignored directories. +exclude = [ + ".bzr", + ".direnv", + ".eggs", + ".git", + ".git-rewrite", + ".hg", + ".mypy_cache", + ".nox", + ".pants.d", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + "__pypackages__", + "_build", + "buck-out", + "build", + "dist", + "node_modules", + "venv", +] + +# Same as Black. +line-length = 88 +indent-width = 4 + +[lint] +extend-select = [ + "I", # isort + # "D", # pydocstyle + "S", # flake8-bandit (Security check), prefer to use bandit directly, it provides better feedback + "PERF", # Perflint + # "ERA", # Eradicate + "C90", # Complexity Check + # "FIX", # flake8-fixme + # "TD", # flake8-todos + "N", # pep8-naming + "COM", # flake8-commas + "C4", # flake8-comprehensions + "ISC", # flake8-implicit-str-concat + "INP", # flake8-no-pep420 + "PIE", # flake8-pie + "Q", # flake8-quotes + "RET", # flake8-return + "SLF", # flake8-self + "SIM", # flake8-simplify + "TID", # flake8-tidy-imports + # "ARG", # flake8-unused-arguments + "PTH", # flake8-use-pathlib + "FLY", # Flynt + # "FURB", # Refurb (requires preview mode) + "UP", # PyUpgrade + # "PL", # Pylint + # "TRY", # tryceratops + "RUF", # Ruff-specific rules +] + +ignore = [ + "PERF203", # try-except in loop + "SIM112", # Use capitalized environment variable + "ISC001", # Conflict with formatter + "COM812", # Conflict with formatter + "PTH123", # Do not force Path.open +] + +[lint.extend-per-file-ignores] +"__init__.py" = ["F401"] + +[lint.mccabe] +max-complexity = 20 + +[format] +# Like Black, use double quotes for strings. +quote-style = "double" + +# Like Black, indent with spaces, rather than tabs. +indent-style = "space" + +# Like Black, respect magic trailing commas. +skip-magic-trailing-comma = false + +# Like Black, automatically detect the appropriate line ending. +line-ending = "auto" diff --git a/tests/.gitkeep b/tests/.gitkeep new file mode 100644 index 0000000..e69de29